Vibe

Vibe Orchestrator

/vibeon | /vibeoff | /vibestatus

Toggle auto-delegate mode — Vibe automatically handles coding tasks without requiring /vibe each time.

For /vibestatus, run both checks and print two lines:

Auto-vibe: ON | OFF
Model: <alias>  (override)  OR  Model: <default from ~/.vibe/config.toml>  (config default)

Auto-mode pre-filter (when flag is set)

When vibe-auto.flag exists, apply this gate before loading the full skill:

/vibe-report

If the user invokes /vibe-report, run ~/tools/delegate-report with any flags extracted from the arguments, display output verbatim, and stop.

The report defaults to vibe runs only. The log is shared across delegate tools (vibe, opencode, gemini); use --all for the cross-delegate comparison or --delegate NAME to scope to a different one.

/vibe-model-pick | /vibe-model-clear

Override the Vibe model for all subsequent delegations without touching ~/.vibe/config.toml.

Aliases are machine-specific — read the actual list (and the default) from [[model]] entries in ~/.vibe/config.toml before suggesting one; never assume an alias from this table exists. Example snapshot from one machine:

Run the bash command, print one confirmation line showing the active model, and stop.

When the user invokes /vibe <instruction>, Claude delegates the implementation to Mistral Vibe via its programmatic mode, supervises in real time, and reports.

Known Limits

Hard constraints — not config options. Full details in SKILL-reference.md.

• UTF-8 / special chars → silent search_replace match failure. Use python3 str.replace() for accented chars or emoji.
• Code duplication → Vibe may re-insert a block already written. Grep for duplicate definitions after every run.
• HTML in prompt → tags like <div> are shell redirects (exit 127). Write HTML content to a temp file; reference the path in the prompt.
• Source code in bash heredoc → quotes/backslashes mangle. Use search_replace directly; never a helper script that replaces code.
• Large files are NOT a blocker (measured 2026-10-01, docs/harness-audit-2026-10-01.md H8). One read_file call returns the first 51,200 bytes with was_truncated: true and the real file_size_bytes; offset/limit page the rest, grep -n finds anchors. Never tell the user "Vibe can't read files over 50 KB". The real risk is Vibe reasoning on the first window only, so for big files the harness injects a grep → read offset/limit → edit instruction. Handing it a big diff to understand is still a bad idea: split by area.
• Calling vibe -p directly hangs without a TTY (it waits for stdin EOF; no session is even created). Always go through vibe-delegate (pty), or add < /dev/null.
• Tool names differ by view. The model sees edit (old_string/new_string); the runtime and the stream log file_system.search_replace. In prompts say "the edit tool" — asking for "search_replace" makes Vibe waste turns on search_tool_functions.
• A turn = one model call, not one tool call. Vibe can issue several independent tool calls per turn (6 reads + 6 edits took 5 turns). For repetitive edits across many files, ask for one run_typescript call that loops with tools.file_system.edit (verified 2026-10-01: 6 files in one call, 4 turns, ~18 % fewer tokens; each edit is still journaled as search_replace, so the WRITE AUDIT stays exact). Otherwise ask for parallel independent calls. Never forbid other tools in the same prompt — a "use the edit tool" line was enough to stop Vibe from batching.
• Never trust Vibe's description of itself — check the session store (H11).
• Files outside the workdir are unreadable → --trust does NOT cover them. Any path outside workdir raises an outside_directory approval that is auto-denied headlessly: the run exits 0 with 0 tool calls and, before the 2026-08-02 parser fix, said nothing at all. Any file the prompt points Vibe at must live inside the workdir. Stage temp inputs in a gitignored dir in the repo, not /tmp.
• Orchestration chain → 6 failure points in order: CLI auth → pseudo-TTY → stream parser → TOML pricing → git diff → JSON log. When a run produces unexpected results, work down this list. Full details in SKILL-reference.md.

Step 1 — Detect workdir

1. git rev-parse --show-toplevel in the current directory.
2. If ambiguous or no git repo → ask with AskUserQuestion.

Step 2 — Decompose the task

Critical rule: keep tasks atomic and focused — one objective, one prompt.

Decomposition for complex tasks:

Sub-task 1: Explore / read relevant files (read-only, 5 turns)
Sub-task 2: Implement change A in file X (8 turns)
Sub-task 3: Implement change B in file Y (8 turns)
Sub-task 4: Verify / test (5 turns)

→ Check git diff between each sub-task before launching the next.

Step 3 — Write the Vibe prompt

The prompt must be self-contained.

Structure:

Stack: Python/Flask, SQLAlchemy, SQLite
Key files: app.py (routes + fetch), models.py (Entry)

TASK: [one single thing to do, stated as an imperative]

CONSTRAINTS:
- [what must not break]
- [expected format if relevant]

VERIFY: grep for "def function_name" in file.py and confirm it exists.

Formulation rules:

• One task per prompt — never "also do X and Y"
• Name the exact files to modify
• Include a grep-based verification criterion (not a file re-read)
• Language: English (better Mistral performance)

Prompt adaptations:

• Any task that defines or calls a specific function: include the exact signature — def validate(data: dict) -> tuple[bool, list[str]]:.
• No fixed signature, but conventions matter: point at the file to read first ("read app.py, follow its route/jsonify style") instead — don't do both, they're substitutes.
• Write/modify tasks: append an output format block:

  OUTPUT FORMAT:
  Modified: <file>
  Does: <one line>
  No other prose.

⚠️ Shell safety: if the prompt contains UTF-8 accented chars, emojis, : in Python/YAML code, or typographic apostrophes — the vibe-delegate script passes them safely via a temp file (printf %q). Never interpolate such a prompt directly into a bash heredoc.

Verification — always use grep, not file re-read:

VERIFY: grep for "def extract_labels" in app.py and confirm it exists.

Step 4 — Launch Vibe

~/tools/vibe-delegate "<workdir>" "<prompt>" [max-turns] [agent] [timeout-secs]

Available agents:

These are Vibe's built-in agents. Custom agents can add to this list, but nothing outside it is guaranteed to exist — an unknown name aborts the run in ~1.5s with Error: Agent 'X' not found.

⚠️ code-reviewer, planner, and code-architect were listed here until 2026-08-02 but do not exist in current Vibe. Use plan for review and planning work. Verify against BUILTIN_AGENTS in vibe/core/agents/models.py if a name is ever in doubt.

Read-only runs write nothing by design — that is success, not WROTE_NOTHING. Do not apply the Step 6 retry/ghostwrite ladder to a plan/explore run.

Recommended max turns:

• Read/explore: 5
• Simple change (1 file): 8
• Medium change (2–3 files): 12
• Never exceed 12 — decompose instead

Background launch:

~/tools/vibe-delegate "<workdir>" "<prompt>" 10 > /tmp/vibe_out.txt 2>&1 &
# Monitor with: tail -f /tmp/vibe_out.txt

Step 5 — Supervise in real time

The script prints live:

=== VIBE START ===
Workdir : /path/to/project
Agent   : default
Turns   : 10
Timeout : 180s
Prompt  : Stack: Python/Flask. File: app.py ...
===================
  [read]  app.py
  [tool]  file: app.py
  [tool]  search_replace [OK] ...
  [vibe]  Done. Converted date to datetime.date in fetch_data().
Tool calls: 5
Delegate tokens (run): 4,800  (last turn: 4,600+200)  |  cost ~$0.0086
Claude Sonnet 4.6 eq: same tokens would cost ~$0.0168  (ratio x2.0)
=== VIBE DONE (exit: 0) ===
=== SYNTAX OK (1 check(s)) ===

=== UNCOMMITTED CHANGES ===
 app.py | 4 ++--
[log] → ~/.local/share/delegate-runs.jsonl  (4800 tokens, exit 0, 34.2s)

Vibe never commits. All changes are left unstaged — git checkout . reverts everything if needed.

Verdict lines (since 2026-09-30) — read these before anything else:

• Last line is === RESULT: OK ... === or === RESULT: FAILED [reason] ... === (or READ-ONLY). FAILED means nothing usable landed, whatever stdout narrated: never report success, run git diff.
• Exit code 3 = vibe exited 0 but the run failed (wrote_nothing, write_mismatch, syntax_error, sr_fail, ...). A vibe-delegate ... && next chain now stops there.
• FAILED [turn_cap] (since 2026-10-01) = Vibe used every --max-turns model call and never gave a final answer. Vibe 2.25 exits 0 on this, so before the check it was logged ok. Files may be changed but the task is likely partial: diff against the task list, then delegate only the missing part.
• === VIBE FINAL ANSWER === (since 2026-10-01) = Vibe's complete closing message, read from the session checkpoint. The [vibe] stream lines are cut at 400 chars — quote this block, not them.
• === WRITE AUDIT (journal vs disk) === lists every edit/write call with its own outcome (call: ok / call: FAILED (reason)) and the disk state. MISMATCH = a successful call that did not land. A failed edit followed by a successful one on the same file is marked recovered and does not make the run FAILED (it used to, wrongly). 0 write attempts = Vibe only explored.
• [PREFLIGHT] large file(s) = a file named in the prompt is >40 KB; the harness appended a grep → read offset/limit → edit instruction. Still pass the anchor with --require.
• Every prompt also gets a RUN BUDGET line (turn count, "use the edit tool", "keep the last turn for a summary"): Vibe has no other way to know its --max-turns.
• VIBE_HARNESS=legacy|unified forces a backend. Benchmarked 2026-10-01: both 4/4 correct; unified faster (19–21 s vs 24–29 s), legacy ~15–30 % fewer tokens. Default (unset) = unified.
• Sessions live in ~/.vibe/logs/session/unified/<uuid>/{journal,chunks} (compact JSON; tool file_system.search_replace, input {file_path, content:[{old_str,new_str}]}). That layout's meta.json has no token stats; vibe-delegate reads them from generations/<CURRENT>/projection-state.json (tokenUsage) and the model from runtime-state.json. 0 tokens / Model: unknown on a new run is a bug, not expected.

Red flags to act on immediately:

Known bugs and workarounds:

If exit non-zero: do not relaunch immediately. Read the diff, understand what was done, fix the prompt.

Mandatory pre-check before declaring WROTE_NOTHING. stdout is a filtered stream, not a record of what Vibe did — the parser can drop or mislabel a write it doesn't recognize the shape of. The session journal is not filtered: ~/.vibe/logs/session/session_<ts>_<id>/messages.jsonl records the exact arguments of every write_file/search_replace call, whether or not the write later succeeded. vibe-delegate already runs this check for you — when the filesystem shows 0 changed files, it scans the journal for the newest session and prints an [RECOVERY] block listing every write attempt found, with char counts, before the syntax-check section. Read that block before concluding the run failed. A run that "wrote nothing" per stdout but shows a few-KB write_file in [RECOVERY] did not fail — the content exists and is very likely usable; treat it as a formatting/parsing problem, not an empty run, and inspect the content in the journal directly:

JOURNAL=$(ls -t ~/.vibe/logs/session/*/messages.jsonl 2>/dev/null | head -1)   # legacy layout only; for unified sessions read WRITE AUDIT
python3 -c "
import json
for line in open('$JOURNAL'):
    m = json.loads(line)
    if m.get('role') != 'assistant': continue
    for tc in (m.get('tool_calls') or []):
        fn = tc.get('function') or {}
        if 'write' in fn.get('name',''):
            print(json.loads(fn['arguments'])['content'])
"

Confirmed case (2026-08-11, a delegated Python project): stdout showed 0 files changed and a turn-limit stop on a temperature.py delegation. The journal held a complete, correct 5,706-char module from the first write_file call — Vibe had simply wrapped it as {"module_docstring": """...."""}\n<real source> instead of emitting raw source, the write step rejected the shape, and Vibe burned the rest of the turn budget on write→rm→write instead of on the actual task. Stripping the one-line JSON envelope recovered the module outright — no retry needed. The retry that was run cost ~180k tokens for a result no better than turn 1's output already sitting in the journal.

If, after reading the journal, there is genuinely no write_file/edit call for the target file at all — that's the real WROTE_NOTHING, and Step 6 applies.