openzoo 0.48.99 → 0.49.1

package/lib/grokui.mjs

@@ -12,7 +12,7 @@ import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSyn
 import { cpus, homedir } from 'node:os';
 import path from 'node:path';
 import { adaptiveTopK, brain, brainRace, brainStream, tierModels, MODEL, PROXY, TIER_NAMES, normalizeTier } from './podagent.mjs';
-import { peekDirectiveStatus, formatRaceStatus, STALE_THINKING_MS, summarizeRaceFailures } from './livestatus.js';
+import { peekDirectiveStatus, formatRaceStatus, STALE_THINKING_MS, summarizeRaceFailures, RACE_EVERY_FAILED } from './livestatus.js';
 import { creditBalance } from './info.js';
 import {
   SUBSCRIPTIONS_PAGE,
@@ -20,6 +20,10 @@ import {
   subscriptionPublicView, parseSubscriptionPaste,
   billingTiers, billingCheckout, fetchBillingKey, ingestBillingKeyResponse,
 } from './subscription.js';
+import {
+  prepareChildDir, finishChildDir, lockWorktree, unlockWorktree,
+  parsePrRef, fetchSpecsForOrigin, agentSlug,
+} from './worktree.mjs';
 
 const PORT = Number(process.env.OZ_GROKUI_PORT || 4173);
 // BIND HOST. Default 127.0.0.1 so the desktop app never exposes a shell-capable
@@ -446,9 +450,28 @@ function loadThreads() {
   } catch { return false; }
 }
 
-function newThread(name, parent, members) {
+function attachChildDir(t, parent, spec) {
+  // Never copy parent.dir — that is the testingcluade bug: every tetris kid
+  // sat in the parent's checkout and collided. Isolated worktree (git) or
+  // ~/.openzoo/grokui-worktrees/<slug> (not git). Same Node process; cwd is t.dir.
+  if (t.dir && t.worktree?.path && existsSync(t.dir)) return t;
+  const ws = prepareChildDir(parent, t.name, spec);
+  t.dir = ws.path;
+  t.worktree = {
+    path: ws.path,
+    branch: ws.branch || null,
+    parentDir: ws.parentDir,
+    kind: ws.kind,
+    repo: ws.repo || null,
+    fetchRef: ws.fetchRef || '',
+    baseRef: ws.baseRef || '',
+  };
+  return t;
+}
+
+function newThread(name, parent, members, spec) {
   const id = randomUUID();
-  // A subagent INHERITS its parent's run mode, working directory and model.
+  // A subagent INHERITS its parent's run mode and model — not its directory.
   //
   // runMode especially: children defaulted to 'ask', so a bot spawned in auto
   // mode emitted a RUN, the harness parked it awaiting approval, and nobody
@@ -456,8 +479,8 @@ function newThread(name, parent, members) {
   // typing…" forever while the parent reported it as working. Spawning from
   // auto and landing in ask is never what the user meant.
   //
-  // dir matters just as much — a child that defaults elsewhere cannot see the
-  // files the parent was sent to work on.
+  // dir is isolated per child (git worktree or ~/.openzoo/grokui-worktrees).
+  // Copying p.dir put every SPAWN in /Users/stacc/testingcluade.
   //
   // tier/race/raceMode for the same reason, and one more: they are the SPEND
   // dial. Setting a project to the expensive tier and then having every
@@ -468,13 +491,13 @@ function newThread(name, parent, members) {
   const p = parent ? threads.get(parent) : null;
   const t = { id, name, color: members ? members[0].color : colorFor(name), parent: parent || null,
     messages: members ? null : [{ role: 'system', content: SYSTEM }],
-    members: members || null, history: [], status: 'idle', createdAt: Date.now(), lastActivityAt: Date.now(),
+    members: members || null, history: [], status: 'idle', turnSeq: 0, createdAt: Date.now(), lastActivityAt: Date.now(),
     ...(p?.runMode ? { runMode: p.runMode } : {}),
-    ...(p?.dir ? { dir: p.dir } : {}),
     ...(p?.model ? { model: p.model } : {}),
     ...(p?.tier ? { tier: p.tier } : {}),
     ...(p?.race ? { race: p.race } : {}),
     ...(p?.raceNeed ? { raceNeed: p.raceNeed } : {}) };
+  if (p) attachChildDir(t, p, spec);
   threads.set(id, t);
   saveThreads();
   return t;
@@ -664,6 +687,47 @@ const NUDGE = 'That reply announced work instead of doing it — no directive li
 const AUTO_CONTINUE = 'AUTO is still on — do not stop and do not ask the user to type continue. '
   + 'Emit the next directive now (RUN:/SPAWN:/SEND:/READ:/WRITE:/GLOB:/FETCH:/MCP:/SERVE:), '
   + 'or DONE: if the job is actually finished.';
+const AUTO_RACE_RETRY = 'AUTO is still on — the last model call failed (race/empty/error). '
+  + 'Do not stop and do not ask the user to type continue. '
+  + 'Emit the next directive now (RUN:/SPAWN:/SEND:/READ:/WRITE:/GLOB:/FETCH:/MCP:/SERVE:), '
+  + 'or DONE: if the job is actually finished.';
+// Said it would, without a directive line. "Spawned X" and "working on it" are
+// in here because they are FALSE without a SPAWN: in the same reply — the bot
+// reports success for something the harness never saw.
+const ANNOUNCEMENT = /\b(?:I(?:'| a)?ll |I will |let me |I'm going to |I am going to |first,? |next,? |now I'll |starting|kicking off|spawn(?:ing|ed)|about to|going to (?:check|run|create|start|install))\b/i;
+const STALLED_OFFER = /\b(?:if you want(?:ed)?,? I can|should I\b|let me know(?: and I['’]ll)?|ready to proceed|want me to|would you like(?: me to)?|spawned \S[\s\S]{0,80}working on it|kicked that off)\b/i;
+function isDoneReply(text) {
+  return /^[ \t>*-]*DONE:/m.test(String(text || ''));
+}
+function isTransientModelFail(text) {
+  const s = String(text || '').trim();
+  if (s === RACE_EVERY_FAILED || /^\(race:\s*every model failed/i.test(s)) return true;
+  if (/^error:/i.test(s)) return true;
+  if (/returned nothing \d+ times|each returned nothing/i.test(s)) return true;
+  return false;
+}
+function isPaymentFailed(text) {
+  return /\b(?:payment failed|HTTP 402|wallet is empty|empty wallet)\b/i.test(String(text || ''));
+}
+// Park only: ask mode, pendingRun, DONE:, 402/empty-wallet, or the hard cap.
+function shouldKeepAuto(t, reply) {
+  if (!t || t.runMode !== 'auto') return false;
+  if (t.pendingRun) return false;
+  if ((t.autoSteps || 0) >= AUTO_MAX_STEPS) return false;
+  if (isDoneReply(reply)) return false;
+  if (isPaymentFailed(reply)) return false;
+  return true;
+}
+function enqueueAutoHop(t, threadId, userText, onEvent) {
+  bindThread(t).catch(() => {});
+  t.autoSteps = (t.autoSteps || 0) + 1;
+  if (t.autoSteps >= AUTO_MAX_STEPS) return false;
+  kickTurn(threadId, userText, onEvent).catch(() => {});
+  return true;
+}
+function autoHopText(reply) {
+  return isTransientModelFail(reply) ? AUTO_RACE_RETRY : AUTO_CONTINUE;
+}
 // PING used to be a read: last-line status, no turn. Idle children stayed idle
 // while the parent treated the dump as evidence they had acted. A ping is a
 // wake — the same harness continue AUTO already uses, unless a custom message
@@ -672,6 +736,10 @@ let runTurnOverride = null;
 function setRunTurnForTest(fn) {
   runTurnOverride = typeof fn === 'function' ? fn : null;
 }
+let brainAskOverride = null;
+function setBrainAskForTest(fn) {
+  brainAskOverride = typeof fn === 'function' ? fn : null;
+}
 function kickTurn(threadId, userText, onEvent, images) {
   // Default to emitToThread so a spawned/pinged kid streams when someone has
   // that thread open. emitToThread is a no-op if nobody is watching.
@@ -708,14 +776,14 @@ const SPAWN_MAX_CHILDREN = Number(process.env.OZ_SPAWN_MAX_CHILDREN)
 
 // Injected fresh on every AUTO turn, never persisted into the thread.
 //
-// The auto loop only continues while directives keep parsing, so a reply that
-// merely OFFERS ends the run — auto silently degrades to ask the moment the
-// model hedges. Observed live: "If you want, I can rewrite the prompt with
-// these fixes folded in", "Spawned mcp-integration — working on it" with
-// nothing spawned, and a user reduced to answering "no, this... impl all".
-// Models are trained to close on a consent question; in auto that instinct is
-// the bug. The system prompt is frozen into a thread at creation, so an
-// existing thread can only be reached by a per-turn message.
+// The auto loop keeps going until DONE:, a real blocking question, or the
+// step cap. A reply that merely OFFERS used to end the run — auto silently
+// degraded to ask the moment the model hedged. Observed live: "If you want,
+// I can rewrite the prompt", "Spawned mcp-integration — working on it" with
+// nothing spawned, and a kid that RAN ls then sat idle. Models are trained
+// to close on a consent question; in auto that instinct is the bug. The
+// system prompt is frozen into a thread at creation, so an existing thread
+// can only be reached by a per-turn message.
 const AUTO_DIRECTIVE = `AUTO MODE IS ON for this thread.
 
 Do the work in this turn. Do not ask whether to proceed, do not offer to do it,
@@ -733,7 +801,11 @@ Announcing an action does not perform it. "Spawned X", "working on it" and
 If a task needs several commands, emit the FIRST one now; you get its real
 output back and continue from there. Only stop to ask when the next step is
 genuinely destructive and irreversible, or when you truly cannot proceed
-without a fact only the user has.`;
+without a fact only the user has.
+
+When the job is actually finished, emit DONE: as the first line. A status
+sentence is not a stop — the harness keeps this thread working until DONE:,
+a real blocking question, or the step cap.`;
 async function bindThread(t) {
   // Only bind what's NEW since the last successful bind, continuing the
   // existing context_id — previously this rebuilt and re-sent the WHOLE
@@ -1241,6 +1313,7 @@ async function handleSlash(task, t) {
     const crew = subtreeOf(t.id);
     if (!crew.length) return 'You have no subagents to send to.';
     for (const x of crew) kickTurn(x.id, arg).catch(() => {});
+    if (t.runMode === 'auto' && pingCanWake(t)) wakeOnPing(t, arg);
     return `Sent down your branch to ${crew.length} bot(s): ${crew.map((x) => x.name).join(', ')}`;
   }
 
@@ -1254,6 +1327,10 @@ async function handleSlash(task, t) {
     return crew.map((x) => {
       const mark = x.id === t.id ? ' (here)' : '';
       if (x.id === t.id) {
+        if (t.runMode === 'auto' && pingCanWake(t)) {
+          wakeOnPing(t, arg);
+          return `  ${x.name}${mark}: pinged, working`;
+        }
         const last = x.history[x.history.length - 1];
         return x.pendingRun ? `  ${x.name}${mark}: BLOCKED — waiting for your approval`
           : x.status === 'thinking' ? `  ${x.name}${mark}: working`
@@ -1331,8 +1408,15 @@ setInterval(() => {
     if (!last || now - last < STALE_THINKING_MS) continue;
     t.turnSeq = (t.turnSeq || 0) + 1;
     try { turnAborts.get(t)?.abort(); } catch { /* none */ }
-    t.status = 'idle';
-    t.liveStatus = '';
+    const lastBot = [...(t.history || [])].reverse().find((h) => h.who === 'bot');
+    const lastText = lastBot?.text || '';
+    if (shouldKeepAuto(t, lastText)) {
+      kickTurn(t.id, isTransientModelFail(lastText) ? AUTO_RACE_RETRY : AUTO_CONTINUE).catch(() => {});
+    } else {
+      t.status = 'idle';
+      t.liveStatus = '';
+      unlockWorktree(t);
+    }
     dirty = true;
   }
   if (dirty) saveThreads();
@@ -1349,7 +1433,7 @@ setInterval(() => {
 const PARALLEL_DIRECTIVE = /^[ \t>*-]*(READ|LS|GLOB|GREP|FETCH|PEEK|MCP):[ \t]*(.+)$/gm;
 
 // Walk a thread dir once, cheaply, skipping the things nobody means to search.
-const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', '.venv', 'venv']);
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', '.venv', 'venv', '.openzoo']);
 function walkDir(base, rel = '', out = [], depth = 0) {
   if (depth > 12 || out.length > 5000) return out;
   let entries = [];
@@ -1591,7 +1675,8 @@ function unwrapDirectiveLine(reply) {
 function isHarnessUserText(text) {
   return /^\((command output|directive result)\)/.test(String(text || ''))
     || String(text || '') === NUDGE
-    || String(text || '') === AUTO_CONTINUE;
+    || String(text || '') === AUTO_CONTINUE
+    || String(text || '') === AUTO_RACE_RETRY;
 }
 
 function firstUserAsk(t) {
@@ -1610,7 +1695,7 @@ function siblingJob(sib) {
   return job.trim().replace(/\s+/g, ' ').slice(0, 400);
 }
 
-function spawnBrief(parent, { refresh = false } = {}) {
+function spawnBrief(parent, { refresh = false, child } = {}) {
   if (!parent) return '';
   const rootId = rootOf(parent).rootId;
   const root = threads.get(rootId) || parent;
@@ -1618,7 +1703,8 @@ function spawnBrief(parent, { refresh = false } = {}) {
   const latest = String(lastUserAsk(parent)?.text || '').trim();
   const recent = (parent.history || []).filter((m) => !isHarnessUserText(m.text)).slice(-8);
   const siblings = [...threads.values()].filter((x) => x.parent === parent.id);
-  const cwd = parent.dir || WORKSPACE_DIR;
+  const cwd = child?.dir || WORKSPACE_DIR;
+  const branch = child?.worktree?.branch;
   const mode = parent.runMode || 'ask';
   const tier = parent.tier || 'medium';
   const race = Number(parent.race) || 0;
@@ -1646,6 +1732,7 @@ function spawnBrief(parent, { refresh = false } = {}) {
   }
   lines.push('', 'WORKING SET:');
   lines.push('cwd: ' + cwd);
+  if (branch) lines.push('branch: ' + branch);
   lines.push('run mode: ' + mode);
   lines.push('tier: ' + tier
     + (race >= 2 ? ' · race ' + (raceNeed > 1 ? raceNeed + ' of ' + race : race) : '')
@@ -1662,7 +1749,8 @@ function spawnBrief(parent, { refresh = false } = {}) {
 }
 
 function childKickoff(parent, childName, task, { fresh = true } = {}) {
-  return spawnBrief(parent, { refresh: !fresh }) + task + spawnPosition(parent, childName);
+  const child = findByName(childName);
+  return spawnBrief(parent, { refresh: !fresh, child }) + task + spawnPosition(parent, childName);
 }
 
 /**
@@ -1684,6 +1772,7 @@ function spawnPosition(parent, childName) {
   if (!parent) return '';
   const depth = rootOf(parent).depth + 1;
   const others = [...threads.values()].filter((x) => x.parent === parent.id && x.name !== childName);
+  const me = findByName(childName);
   return '\n\n--- your place in the team ---\n'
     + `You are "${childName}", spawned by "${parent.name}". You are at tier ${depth} of this project.\n`
     + (others.length
@@ -1695,8 +1784,12 @@ function spawnPosition(parent, childName) {
     + 'that is how a team becomes sixteen bots and zero artifacts. SPAWN only if your slice '
     + 'contains genuinely independent work that NO existing sibling covers, and name any agent '
     + 'you do spawn after what it owns, never "agent-1".\n'
-    + 'Work in your own directory so you cannot collide with a sibling: '
-    + `type  /dir <path>  if you need one. Everything else — build it yourself, now.\n`;
+    + (me?.dir
+      ? `Your working directory is ${me.dir}`
+        + (me.worktree?.branch ? ` on ${me.worktree.branch}` : '')
+        + ' — isolated from the parent checkout. Write here, not in the parent tree.\n'
+      : '')
+    + 'Everything else — build it yourself, now.\n';
 }
 
 /**
@@ -1809,10 +1902,15 @@ async function tryDirective(reply, originId, onEvent) {
     const notes = [];
     for (const { name, task } of parsed) {
       const existing = findByName(name);
-      if (existing) { notes.push(`${name} already exists — woke it to keep working.`); made.push({ t: existing, task, fresh: false }); continue; }
+      if (existing) {
+        attachChildDir(existing, parent, task);
+        notes.push(`${name} already exists — woke it to keep working.`);
+        made.push({ t: existing, task, fresh: false });
+        continue;
+      }
       const siblings = [...threads.values()].filter((x) => x.parent === originId).length;
       if (siblings >= SPAWN_MAX_CHILDREN) { notes.push(`Not spawning "${name}": already at ${SPAWN_MAX_CHILDREN} subagents.`); continue; }
-      made.push({ t: newThread(name, originId), task, fresh: true });
+      made.push({ t: newThread(name, originId, undefined, task), task, fresh: true });
     }
     // Every thread now exists, so spawnPosition sees the COMPLETE cohort.
     for (const { t: sub, task, fresh } of made) {
@@ -1839,6 +1937,7 @@ async function tryDirective(reply, originId, onEvent) {
       // Repeat SPAWN is a wake, not a CONTEXT REFRESH. childKickoff({fresh:false})
       // restates the original job and tells the child it already exists — MEASURED,
       // the crew flipped to that preview, thought once, and sat.
+      attachChildDir(existing, threads.get(originId), task);
       wakeOnPing(existing);
       return `${name} already exists — woke it to keep working.`;
     }
@@ -1850,7 +1949,7 @@ async function tryDirective(reply, originId, onEvent) {
         + `(limit ${SPAWN_MAX_CHILDREN}). Reuse one with  SEND: <name> | <task>  — `
         + `every live subagent costs paid calls.`;
     }
-    const sub = newThread(name, originId);
+    const sub = newThread(name, originId, undefined, task);
     // The child gets the ORIGINATING brief plus its own job — see spawnBrief.
     kickTurn(sub.id, childKickoff(threads.get(originId), name, task)).catch(() => {}); // fire and forget
     return `Spawned ${name} — working on it.`;
@@ -1892,7 +1991,7 @@ async function tryDirective(reply, originId, onEvent) {
       return `Cannot create "${name}": this thread already has ${siblings} subagents `
         + `(limit ${SPAWN_MAX_CHILDREN}). Reuse one with  SEND: <existing name> | <task>.`;
     }
-    const sub = newThread(name, originId);
+    const sub = newThread(name, originId, undefined, msg);
     kickTurn(sub.id, childKickoff(threads.get(originId), name, msg)).catch(() => {});
     return `${name} did not exist — spawned it with that message as its task.`;
   }
@@ -1931,6 +2030,15 @@ async function tryDirective(reply, originId, onEvent) {
     wakeOnPing(target);
     return `${name}: pinged, working`;
   }
+  const done = /^[ \t>*-]*DONE:\s*/m.exec(reply);
+  if (done) {
+    const t = threads.get(originId);
+    if (!t) return 'Done.';
+    const result = finishChildDir(t);
+    if (result.removed) return 'Done — clean worktree removed.';
+    if (result.kept) return 'Done — worktree kept (has local work).';
+    return 'Done.';
+  }
   const peek = /^[ \t>*-]*PEEK:\s*(.+)/m.exec(reply);
   if (peek) {
     const name = peek[1].trim();
@@ -2318,7 +2426,11 @@ async function runTurn(threadId, userText, onEvent, images) {
   // status=thinking and the UI on "…".
   if (!isHarnessUserText(userText)) t.turnSeq = (t.turnSeq || 0) + 1;
   const seq = t.turnSeq || 0;
-  const stillMine = () => threads.get(threadId)?.turnSeq === seq;
+  // Missing turnSeq is 0, not undefined. A ping/AUTO_CONTINUE as the first
+  // message used to make stillMine() always false (undefined === 0), so the
+  // RUN ran or the model was paid and then the hop bailed before chaining —
+  // kids looked "pinged" then dead.
+  const stillMine = () => (threads.get(threadId)?.turnSeq || 0) === seq;
   const paint = (ev) => {
     if (!stillMine()) return;
     if (ev.type === 'status' && ev.detail && t.status === 'thinking') t.liveStatus = ev.detail;
@@ -2333,16 +2445,19 @@ async function runTurn(threadId, userText, onEvent, images) {
   try { turnAborts.get(t)?.abort(); } catch { /* none */ }
   const turnAbort = new AbortController();
   turnAborts.set(t, turnAbort);
+  lockWorktree(t);
   const raceN = Math.min(Number(t.race) || 0, 4);
   const raceNeed = Math.min(Math.max(Number(t.raceNeed) || 1, 1), raceN || 1);
   t.liveStatus = (!t.model && raceN >= 2) ? formatRaceStatus(0, raceNeed) : 'waiting on model…';
   let chained = false;
   let parked = false;
+  let lastReply = '';
   try {
   if (t.members) {
     // sequential, not parallel: each member's context is rebuilt from
     // t.history right before its turn, so it sees every reply (including
     // spawns/sends) the earlier members in THIS round already made
+    let memberReply = '';
     for (const m of t.members) {
       if (!stillMine()) return;
       const msgs = buildMemberMessages(t, m);
@@ -2356,6 +2471,7 @@ async function runTurn(threadId, userText, onEvent, images) {
       } catch (e) { r = `error: ${e.message}`; }
       if (!stillMine()) return;
       r = stripThinkTags(r);
+      memberReply = r;
       const runCmd = parseRun(r);
       if (runCmd) {
         const command = runCmd;
@@ -2365,6 +2481,7 @@ async function runTurn(threadId, userText, onEvent, images) {
           const shown = `$ ${command}\n${output}`;
           t.history.push({ who: 'bot', text: shown, name: m.name, color: m.color });
           paint({ type: 'final', name: m.name, color: m.color, text: shown });
+          memberReply = shown;
           // this member's turn is done; the round continues to the next member
           continue;
         }
@@ -2381,8 +2498,13 @@ async function runTurn(threadId, userText, onEvent, images) {
       const finalText = ack ?? (r || '(no response)');
       t.history.push({ who: 'bot', text: finalText, name: m.name, color: m.color });
       paint({ type: 'final', name: m.name, color: m.color, text: finalText });
+      memberReply = r;
     }
     bindThread(t).catch(() => {});
+    lastReply = memberReply;
+    if (shouldKeepAuto(t, memberReply)) {
+      chained = enqueueAutoHop(t, threadId, autoHopText(memberReply), onEvent);
+    }
     return;
   }
   // A real message from the user resets the auto budget AND the announcement
@@ -2421,6 +2543,11 @@ async function runTurn(threadId, userText, onEvent, images) {
   // `attempt` exists because a retry must be allowed to land somewhere else:
   // see the empty-completion loop below.
   const ask = async (attempt = 0) => {
+    if (brainAskOverride) {
+      return String(await brainAskOverride({
+        thread: t, attempt, userText, messages: callMsgs,
+      }) ?? '').trim();
+    }
     const emit = (delta, meta) => paint({
       type: 'delta', name: t.name, color: t.color, delta,
       ...(meta?.replace ? { replace: true } : {}),
@@ -2468,7 +2595,7 @@ async function runTurn(threadId, userText, onEvent, images) {
     // sick provider. Empties are per-model and uncorrelated, so moving is the
     // fix. A thread pinned with /model stays pinned; that was an explicit
     // choice and silently answering as something else would be worse.
-    for (let i = 0; !reply && i < AUTO_EMPTY_RETRIES; i++) {
+    for (let i = 0; (!reply || isTransientModelFail(reply)) && i < AUTO_EMPTY_RETRIES; i++) {
       paint({ type: 'status', name: t.name, color: t.color, detail: 'retrying…' });
       await new Promise((r) => setTimeout(r, 400 * (i + 1)));
       if (!stillMine()) return;
@@ -2484,6 +2611,7 @@ async function runTurn(threadId, userText, onEvent, images) {
   }
   if (!stillMine()) return;
   reply = stripThinkTags(reply);
+  lastReply = reply;
   t.messages.push({ role: 'assistant', content: reply });
   const runCmd = parseRun(reply);
   if (runCmd) {
@@ -2503,24 +2631,13 @@ async function runTurn(threadId, userText, onEvent, images) {
       // Bounded, because this is a loop that spends real money on every hop:
       // AUTO_MAX_STEPS chained commands per user message, reset whenever the
       // user speaks again.
-      t.autoSteps = (t.autoSteps || 0) + 1;
-      if (t.autoSteps < AUTO_MAX_STEPS) {
-        // BIND BEFORE CHAINING. bindThread only ran at the end of a normal
-        // turn, and both auto paths return before reaching it — so in auto
-        // mode nothing was ever bound, exactly when the agent produces the
-        // most material (command output, GLOB results, MCP tool lists). The
-        // holographic context stopped growing precisely when it mattered.
-        bindThread(t).catch(() => {});
-        chained = true;
-        runTurn(threadId, condense('(command output)', output), onEvent).catch(() => {});
-      } else {
-        // Do not park. A "say continue" note is the failure mode auto exists
-        // to avoid — inject continue and keep going until DONE or ask.
-        t.autoSteps = 0;
-        bindThread(t).catch(() => {});
-        chained = true;
-        runTurn(threadId, AUTO_CONTINUE, onEvent).catch(() => {});
-      }
+      // BIND BEFORE CHAINING. bindThread only ran at the end of a normal
+      // turn, and both auto paths return before reaching it — so in auto
+      // mode nothing was ever bound, exactly when the agent produces the
+      // most material (command output, GLOB results, MCP tool lists). The
+      // holographic context stopped growing precisely when it mattered.
+      lastReply = shown;
+      chained = enqueueAutoHop(t, threadId, condense('(command output)', output), onEvent);
       return;
     }
     {
@@ -2550,16 +2667,8 @@ async function runTurn(threadId, userText, onEvent, images) {
   // Same budget as RUN (shared t.autoSteps, reset when the user speaks), so
   // this cannot spend more than a chained RUN loop already could.
   if (t.runMode === 'auto' && ack !== null && ack !== undefined
-      && !/^[ \t>*-]*DONE:/m.test(reply)) {
-    t.autoSteps = (t.autoSteps || 0) + 1;
-    bindThread(t).catch(() => {});   // bind every hop, not just the last one
-    chained = true;
-    if (t.autoSteps < AUTO_MAX_STEPS) {
-      runTurn(threadId, condense('(directive result)', ack), onEvent).catch(() => {});
-    } else {
-      t.autoSteps = 0;
-      runTurn(threadId, AUTO_CONTINUE, onEvent).catch(() => {});
-    }
+      && !isDoneReply(reply)) {
+    chained = enqueueAutoHop(t, threadId, condense('(directive result)', ack), onEvent);
     return;
   }
 
@@ -2574,49 +2683,43 @@ async function runTurn(threadId, userText, onEvent, images) {
   // AUTO_DIRECTIVE already forbids this in the prompt, and models do it anyway.
   // A prompt rule with no enforcement is a suggestion. Re-ask once, in-band.
   //
-  // NARROW ON PURPOSE. It fires only on announcement language, never on a plain
-  // answer — auto is also how you hold an ordinary conversation, and nudging a
-  // finished reply would spend a turn arguing with a bot that already
-  // succeeded. Once per turn (autoNudged), so a model that announces twice
-  // still stops instead of looping on the user's wallet.
+  // NUDGE announcements (stronger than a bare continue). Plain replies used
+  // to park here; they now fall through to AUTO_CONTINUE unless DONE: or a
+  // real blocking question. The step cap is the wallet bound.
   if (t.runMode === 'auto' && (ack === null || ack === undefined)
       && (STALLED_OFFER.test(reply) || ANNOUNCEMENT.test(reply))) {
     // Offers and "Spawned X — working on it" with no directive must not end
     // the run. The old once-only autoNudged gate parked the thread after one
-    // hedge and the user typed continue. Keep going; AUTO_MAX_STEPS injects
-    // another continue rather than stopping.
+    // hedge and the user typed continue.
     t.autoNudged = true;
-    t.autoSteps = (t.autoSteps || 0) + 1;
-    bindThread(t).catch(() => {});
-    chained = true;
-    if (t.autoSteps < AUTO_MAX_STEPS) {
-      runTurn(threadId, NUDGE, onEvent).catch(() => {});
-    } else {
-      t.autoSteps = 0;
-      runTurn(threadId, AUTO_CONTINUE, onEvent).catch(() => {});
-    }
+    chained = enqueueAutoHop(t, threadId, NUDGE, onEvent);
+    return;
+  }
+
+  // After any auto reply that is not DONE: and not waiting on approval,
+  // kick immediately. Race/empty/error uses AUTO_RACE_RETRY.
+  if (shouldKeepAuto(t, reply)) {
+    chained = enqueueAutoHop(t, threadId, autoHopText(reply), onEvent);
     return;
   }
   bindThread(t).catch(() => {});
   } finally {
-    // A hung or thrown brainStream used to leave t.status = 'thinking' and the
-    // UI on mute "…" forever. Always idle unless this hop chained or parked
-    // on an approval — the next runTurn sets thinking again itself.
-    if (stillMine() && !chained && !parked && !t.pendingRun) {
-      t.status = 'idle';
-      t.liveStatus = '';
+    // Idle only when this hop should not keep AUTO going: DONE:, pendingRun,
+    // ask mode, 402/empty-wallet, or the hard cap. Otherwise kick again.
+    if (stillMine() && !chained && !parked) {
+      if (shouldKeepAuto(t, lastReply)) {
+        enqueueAutoHop(t, threadId, autoHopText(lastReply), onEvent);
+      } else if (!t.pendingRun) {
+        t.status = 'idle';
+        t.liveStatus = '';
+        unlockWorktree(t);
+      }
     }
     t.lastActivityAt = Date.now();
     saveThreads();
   }
 }
 
-// Said it would, without a directive line. "Spawned X" and "working on it" are
-// in here because they are FALSE without a SPAWN: in the same reply — the bot
-// reports success for something the harness never saw.
-const ANNOUNCEMENT = /\b(?:I(?:'| a)?ll |I will |let me |I'm going to |I am going to |first,? |next,? |now I'll |starting|kicking off|spawn(?:ing|ed)|about to|going to (?:check|run|create|start|install))\b/i;
-const STALLED_OFFER = /\b(?:if you want(?:ed)?,? I can|should I\b|let me know(?: and I['’]ll)?|ready to proceed|want me to|would you like(?: me to)?|spawned \S[\s\S]{0,80}working on it|kicked that off)\b/i;
-
 /**
  * The PROJECT a thread belongs to = the root of its spawn tree, and how deep
  * it sits. Every thread already carried the parent id; nothing ever walked it, so
@@ -5171,6 +5274,8 @@ const server = http.createServer((req, res) => {
     return;
   }
   if (req.method === 'DELETE' && req.url.startsWith('/threads/')) {
+    const doomed = threads.get(req.url.split('/')[2]);
+    if (doomed) finishChildDir(doomed);
     threads.delete(req.url.split('/')[2]);
     saveThreads();
     res.writeHead(200, { 'content-type': 'application/json' });
@@ -5304,6 +5409,9 @@ server.listen(PORT, BIND, () => console.log(`[grokui] http://${BIND === '0.0.0.0
 export {
   tryDirective, ensureWorkspacePort, isPreviewableRel, previewAck, workspaceFileUrl,
   parseRun, looksLikeMcpAsBash, stripThinkTags, safeResolveIn, inDir, listDir,
-  handleSlash, newThread, setRunTurnForTest, AUTO_CONTINUE, pingWakeText, pingCanWake,
-  childKickoff,
+  handleSlash, newThread, setRunTurnForTest, setBrainAskForTest, runTurn,
+  AUTO_CONTINUE, AUTO_RACE_RETRY, pingWakeText, pingCanWake, shouldKeepAuto,
+  isDoneReply, isTransientModelFail, enqueueAutoHop, childKickoff, findByName,
+  attachChildDir, finishChildDir,
+  lockWorktree, unlockWorktree, parsePrRef, fetchSpecsForOrigin, agentSlug,
 };

package/lib/worktree.mjs

@@ -0,0 +1,424 @@
+// Desktop grokui SPAWN isolation — Claude Code worktrees + UltraCode
+// spawn_agent_worktree. Not ported to iOS/Android/Seeker/PSG1 (no local FS).
+//
+// Git goes through dugite's bundled binary, never PATH `git`.
+import { execFileSync } from 'node:child_process';
+import {
+  appendFileSync, cpSync, existsSync, mkdirSync, readdirSync,
+  readFileSync, rmSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { setupEnvironment } from 'dugite';
+
+const FETCH_MS = 8000;
+const GIT_MS = 15000;
+
+export function agentSlug(name) {
+  const pr = parsePrRef(name);
+  if (pr) return `pr-${pr.n}`;
+  const s = String(name || 'agent').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64);
+  return s || 'agent';
+}
+
+/** #123, GitHub PR URL, GitLab MR URL, or a generic /pull/N. */
+export function parsePrRef(text) {
+  const s = String(text || '').trim();
+  if (!s) return null;
+  const hash = /^#(\d+)\b/.exec(s);
+  if (hash) return { n: Number(hash[1]) };
+  const gh = /github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)/i.exec(s);
+  if (gh) return { n: Number(gh[1]), host: 'github.com' };
+  const gl = /gitlab\.com\/\S+\/-\/merge_requests\/(\d+)/i.exec(s);
+  if (gl) return { n: Number(gl[1]), host: 'gitlab.com' };
+  const pull = /\/pull\/(\d+)\b/i.exec(s);
+  if (pull) return { n: Number(pull[1]) };
+  return null;
+}
+
+export function extractPrFromSpawn(name, spec) {
+  const fromName = parsePrRef(name);
+  if (fromName) return fromName;
+  const body = String(spec || '').trim();
+  if (!body) return null;
+  const first = body.split(/\s+/)[0];
+  return parsePrRef(first) || parsePrRef(body.split('|')[0].trim()) || parsePrRef(body);
+}
+
+/** github.com → pull/N/head; gitlab.com → merge-requests/N/head; else pull first. */
+export function fetchSpecsForOrigin(originUrl, n) {
+  const url = String(originUrl || '');
+  if (/github\.com/i.test(url)) return [`pull/${n}/head`];
+  if (/gitlab\.com/i.test(url)) return [`merge-requests/${n}/head`];
+  return [`pull/${n}/head`, `merge-requests/${n}/head`];
+}
+
+/** Absolute dugite binary, or '' if the embed is missing. Never PATH `git`. */
+export function bundledGitPath() {
+  try {
+    const { gitLocation } = setupEnvironment({});
+    return gitLocation && existsSync(gitLocation) ? gitLocation : '';
+  } catch {
+    return '';
+  }
+}
+
+function resolveGitRunner() {
+  let gitLocation = '';
+  let env = {};
+  try {
+    const setup = setupEnvironment({
+      GIT_TERMINAL_PROMPT: '0',
+      GIT_CONFIG_NOSYSTEM: '1',
+    });
+    gitLocation = setup.gitLocation;
+    env = setup.env;
+  } catch { /* setup failed */ }
+  if (!gitLocation || !existsSync(gitLocation)) {
+    throw new Error('dugite embedded git is missing — SPAWN will not call PATH git');
+  }
+  return { bin: gitLocation, env, bundled: true };
+}
+
+let lastGitBinary = '';
+export function gitBinary() { return lastGitBinary; }
+
+/** Dugite bundled git only. Never exec `git` from PATH. */
+export function git(args, cwd, { allowFail = false, timeout = GIT_MS } = {}) {
+  let bin, env;
+  try {
+    ({ bin, env } = resolveGitRunner());
+  } catch (e) {
+    if (allowFail) return '';
+    throw e;
+  }
+  lastGitBinary = bin;
+  try {
+    return execFileSync(bin, ['-c', 'safe.directory=*', ...args], {
+      cwd,
+      env,
+      encoding: 'utf8',
+      timeout,
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+  } catch (e) {
+    if (allowFail) return '';
+    const err = new Error((e.stderr || e.message || '').toString().trim() || 'git failed');
+    err.code = e.status;
+    throw err;
+  }
+}
+
+export function githubRepoFromOrigin(originUrl) {
+  const m = /github\.com[:/]([^/]+)\/([^/.]+)/i.exec(String(originUrl || ''));
+  return m ? { owner: m[1], repo: m[2] } : null;
+}
+
+export function githubPullApiUrl(originUrl, n) {
+  const r = githubRepoFromOrigin(originUrl);
+  return r ? `https://api.github.com/repos/${r.owner}/${r.repo}/pulls/${n}` : null;
+}
+
+export function gitlabProjectFromOrigin(originUrl) {
+  const m = /gitlab\.com[:/](.+?)(?:\.git)?$/i.exec(String(originUrl || '').replace(/\/+$/, ''));
+  return m ? m[1].replace(/\.git$/i, '') : null;
+}
+
+export function gitlabMrApiUrl(originUrl, n) {
+  const project = gitlabProjectFromOrigin(originUrl);
+  return project
+    ? `https://gitlab.com/api/v4/projects/${encodeURIComponent(project)}/merge_requests/${n}`
+    : null;
+}
+
+function httpGetJsonSync(url) {
+  const src = `
+    const r = await fetch(${JSON.stringify(url)}, {
+      headers: { 'user-agent': 'openzoo-grokui', accept: 'application/json' },
+    });
+    if (!r.ok) process.exit(1);
+    process.stdout.write(await r.text());
+  `;
+  const body = execFileSync(process.execPath, ['--input-type=module', '-e', src], {
+    encoding: 'utf8',
+    timeout: FETCH_MS,
+    maxBuffer: 2 * 1024 * 1024,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return JSON.parse(body);
+}
+
+/** GitHub/GitLab API → commit SHA when `git fetch pull/N/head` cannot. */
+export function fetchPrHeadShaViaApi(originUrl, n) {
+  const gh = githubPullApiUrl(originUrl, n);
+  if (gh) {
+    try {
+      const j = httpGetJsonSync(gh);
+      if (j?.head?.sha) return String(j.head.sha);
+    } catch { /* */ }
+  }
+  const gl = gitlabMrApiUrl(originUrl, n);
+  if (gl) {
+    try {
+      const j = httpGetJsonSync(gl);
+      if (j?.sha) return String(j.sha);
+    } catch { /* */ }
+  }
+  return '';
+}
+
+export function isolatedWorktreesHome(home = homedir()) {
+  return path.join(home, '.openzoo', 'grokui-worktrees');
+}
+
+export function isGitRepo(dir) {
+  if (!dir || !existsSync(dir)) return false;
+  return git(['rev-parse', '--is-inside-work-tree'], dir, { allowFail: true }) === 'true';
+}
+
+export function mainRepoRoot(dir) {
+  if (!isGitRepo(dir)) return null;
+  let common = git(['rev-parse', '--path-format=absolute', '--git-common-dir'], dir, { allowFail: true });
+  if (!common) {
+    const rel = git(['rev-parse', '--git-common-dir'], dir, { allowFail: true });
+    common = rel ? path.resolve(dir, rel) : '';
+  }
+  if (!common) return null;
+  if (common.endsWith('.git')) return path.dirname(common);
+  return common;
+}
+
+export function originUrl(repo) {
+  return git(['remote', 'get-url', 'origin'], repo, { allowFail: true });
+}
+
+export function freshBaseRef(repo) {
+  const sym = git(['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD'], repo, { allowFail: true });
+  if (sym) return sym.replace(/^refs\/remotes\//, '');
+  for (const cand of ['origin/main', 'origin/master', 'main', 'master']) {
+    if (git(['rev-parse', '--verify', cand], repo, { allowFail: true })) return cand;
+  }
+  return 'HEAD';
+}
+
+function ensureExclude(repo) {
+  const common = git(['rev-parse', '--path-format=absolute', '--git-common-dir'], repo, { allowFail: true })
+    || path.join(repo, '.git');
+  const exclude = path.join(common, 'info', 'exclude');
+  try { mkdirSync(path.dirname(exclude), { recursive: true }); } catch { /* */ }
+  let cur = '';
+  try { cur = readFileSync(exclude, 'utf8'); } catch { /* */ }
+  if (!cur.includes('.openzoo/worktrees')) {
+    appendFileSync(exclude, (cur.endsWith('\n') || !cur ? '' : '\n') + '.openzoo/worktrees/\n');
+  }
+}
+
+function worktreeListed(repo, dest) {
+  const list = git(['worktree', 'list', '--porcelain'], repo, { allowFail: true });
+  const want = path.resolve(dest);
+  for (const block of list.split('\n\n')) {
+    const line = block.split('\n').find((l) => l.startsWith('worktree '));
+    if (line && path.resolve(line.slice(9).trim()) === want) return true;
+  }
+  return false;
+}
+
+function simpleGlobMatch(pattern, rel) {
+  const p = String(pattern || '').replace(/\\/g, '/').replace(/\/+$/, '');
+  const r = String(rel || '').replace(/\\/g, '/');
+  if (!p) return false;
+  if (!p.includes('*') && !p.includes('?')) {
+    return r === p || r.endsWith('/' + p) || path.basename(r) === p;
+  }
+  const re = new RegExp('^' + p.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+  return re.test(r) || re.test(path.basename(r));
+}
+
+/** Claude .worktreeinclude — copy matching gitignored files. Optional, never blocks. */
+export function copyWorktreeIncludes(repo, dest) {
+  const spec = path.join(repo, '.worktreeinclude');
+  if (!existsSync(spec) || !existsSync(dest)) return 0;
+  const patterns = readFileSync(spec, 'utf8').split(/\r?\n/)
+    .map((l) => l.trim()).filter((l) => l && !l.startsWith('#'));
+  if (!patterns.length) return 0;
+  const ignored = git(['ls-files', '-oi', '--exclude-standard', '-z'], repo, { allowFail: true })
+    .split('\0').filter(Boolean);
+  let n = 0;
+  for (const rel of ignored) {
+    if (!patterns.some((p) => simpleGlobMatch(p, rel))) continue;
+    const from = path.join(repo, rel);
+    const to = path.join(dest, rel);
+    try {
+      if (!existsSync(from)) continue;
+      mkdirSync(path.dirname(to), { recursive: true });
+      cpSync(from, to);
+      n += 1;
+    } catch { /* optional */ }
+  }
+  return n;
+}
+
+export function worktreePath(repo, slug) {
+  return path.join(repo, '.openzoo', 'worktrees', slug);
+}
+
+export function worktreeBranch(slug) {
+  return `worktree-${slug}`;
+}
+
+function addWorktree(repo, slug, { pr = null } = {}) {
+  const dest = worktreePath(repo, slug);
+  const branch = worktreeBranch(slug);
+  mkdirSync(path.dirname(dest), { recursive: true });
+  ensureExclude(repo);
+
+  if (existsSync(dest) && worktreeListed(repo, dest)) {
+    return {
+      path: dest, branch, repo, reused: true,
+      fetchRef: pr?.n ? fetchSpecsForOrigin(originUrl(repo), pr.n)[0] : '',
+    };
+  }
+  if (existsSync(dest)) {
+    try { rmSync(dest, { recursive: true, force: true }); } catch { /* */ }
+  }
+
+  let base = freshBaseRef(repo);
+  let fetchRef = '';
+  if (pr?.n) {
+    const origin = originUrl(repo);
+    const specs = fetchSpecsForOrigin(origin, pr.n);
+    for (const spec of specs) {
+      try {
+        git(['fetch', '--no-tags', 'origin', spec], repo, { timeout: FETCH_MS });
+        if (git(['rev-parse', '--verify', 'FETCH_HEAD'], repo, { allowFail: true })) {
+          fetchRef = spec;
+          base = 'FETCH_HEAD';
+          break;
+        }
+      } catch { /* next spec */ }
+    }
+    if (!fetchRef && origin) {
+      const sha = fetchPrHeadShaViaApi(origin, pr.n);
+      if (sha) {
+        try {
+          git(['fetch', '--no-tags', 'origin', sha], repo, { timeout: FETCH_MS });
+          if (git(['rev-parse', '--verify', sha], repo, { allowFail: true })) {
+            fetchRef = specs[0];
+            base = sha;
+          }
+        } catch { /* isolated fallback */ }
+      }
+    }
+  }
+
+  const hasBranch = Boolean(git(['rev-parse', '--verify', `refs/heads/${branch}`], repo, { allowFail: true }));
+  try {
+    if (hasBranch) git(['worktree', 'add', dest, branch], repo);
+    else git(['worktree', 'add', '-b', branch, dest, base], repo);
+  } catch (e) {
+    if (!existsSync(dest)) throw e;
+  }
+  try { copyWorktreeIncludes(repo, dest); } catch { /* optional */ }
+  return {
+    path: dest, branch, repo, reused: hasBranch, baseRef: base,
+    ...(fetchRef ? { fetchRef } : {}),
+    ...(pr?.n ? { pr: pr.n } : {}),
+  };
+}
+
+function isolatedChildDir(parentDir, slug) {
+  let dest = path.join(isolatedWorktreesHome(), slug);
+  const parent = path.resolve(parentDir);
+  if (dest === parent || dest.startsWith(parent + path.sep)) {
+    dest = path.join(homedir(), '.openzoo', 'grokui-worktrees-out', slug);
+  }
+  if (dest === parent) throw new Error('refusing to isolate a child into the parent cwd');
+  mkdirSync(dest, { recursive: true });
+  return { path: dest, branch: null, kind: 'isolated' };
+}
+
+/**
+ * Isolated cwd for a SPAWNed grokui thread (same Node process; shell cwd = t.dir).
+ * Git parent → <repo>/.openzoo/worktrees/<slug> on worktree-<slug>.
+ * Non-git → ~/.openzoo/grokui-worktrees/<slug>, never the parent dir.
+ */
+export function prepareChildDir(parent, name, spec) {
+  const parentDir = path.resolve(parent?.dir || process.env.OZ_WORKSPACE_DIR
+    || path.join(homedir(), '.openzoo', 'grokui-workspace'));
+  const pr = extractPrFromSpawn(name, spec);
+  const slug = pr && parsePrRef(name) ? `pr-${pr.n}` : agentSlug(name);
+  const repo = mainRepoRoot(parentDir);
+  if (repo) {
+    try {
+      const ws = addWorktree(repo, slug, { pr });
+      return {
+        path: ws.path,
+        branch: ws.branch,
+        parentDir,
+        kind: 'worktree',
+        repo,
+        fetchRef: ws.fetchRef || '',
+        baseRef: ws.baseRef,
+      };
+    } catch { /* fall back to isolated, still not parent cwd */ }
+  }
+  return { ...isolatedChildDir(parentDir, slug), parentDir };
+}
+
+export function worktreeHasWork(wt) {
+  if (!wt?.path || !existsSync(wt.path)) return false;
+  if (wt.kind === 'isolated' || !wt.branch) {
+    try { return readdirSync(wt.path).length > 0; } catch { return false; }
+  }
+  if (git(['status', '--porcelain'], wt.path, { allowFail: true })) return true;
+  const base = wt.baseRef && wt.baseRef !== 'FETCH_HEAD' && wt.baseRef !== 'HEAD'
+    ? wt.baseRef
+    : (wt.repo ? freshBaseRef(wt.repo) : 'HEAD');
+  if (Number(git(['rev-list', '--count', `${base}..HEAD`], wt.path, { allowFail: true })) > 0) return true;
+  const unpushed = git(['rev-list', '--count', '@{upstream}..HEAD'], wt.path, { allowFail: true });
+  return Boolean(unpushed && Number(unpushed) > 0);
+}
+
+export function lockWorktree(wtOrThread) {
+  const wt = wtOrThread?.worktree || wtOrThread;
+  if (!wt?.path || !wt.branch || !existsSync(wt.path)) return false;
+  git(['worktree', 'lock', '--reason', 'openzoo spawn', wt.path], wt.repo || wt.path, { allowFail: true });
+  wt.locked = true;
+  return true;
+}
+
+export function unlockWorktree(wtOrThread) {
+  const wt = wtOrThread?.worktree || wtOrThread;
+  if (!wt?.path || !wt.branch) return false;
+  git(['worktree', 'unlock', wt.path], wt.repo || wt.path, { allowFail: true });
+  wt.locked = false;
+  return true;
+}
+
+/** Clean worktree → remove + delete the branch we created. Dirty → keep. */
+export function finishChildDir(wtOrThread) {
+  const thread = wtOrThread && wtOrThread.worktree ? wtOrThread : null;
+  const wt = thread?.worktree || wtOrThread;
+  if (!wt?.path) return { skipped: true };
+  unlockWorktree(wt);
+  if (worktreeHasWork(wt)) return { kept: true, path: wt.path, branch: wt.branch };
+  if (wt.kind === 'worktree' && wt.repo && wt.branch) {
+    git(['worktree', 'remove', '--force', wt.path], wt.repo, { allowFail: true });
+    git(['branch', '-D', wt.branch], wt.repo, { allowFail: true });
+  }
+  try { if (existsSync(wt.path)) rmSync(wt.path, { recursive: true, force: true }); } catch { /* */ }
+  if (thread) delete thread.worktree;
+  return { removed: true, path: wt.path, branch: wt.branch };
+}
+
+export function isWorktreeLocked(repo, dest) {
+  const list = git(['worktree', 'list', '--porcelain'], repo, { allowFail: true });
+  const want = path.resolve(dest);
+  let current = '';
+  for (const line of list.split('\n')) {
+    if (line.startsWith('worktree ')) current = path.resolve(line.slice(9).trim());
+    if ((line === 'locked' || line.startsWith('locked ')) && current === want) return true;
+  }
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.99",
+  "version": "0.49.1",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",
@@ -22,6 +22,7 @@
     "@modelcontextprotocol/sdk": "^1.12.0",
     "@solana/spl-token": "^0.4.14",
     "@solana/web3.js": "^1.98.4",
+    "dugite": "^3.2.3",
     "selfsigned": "^5.5.0",
     "viem": "^2.21.0",
     "zod": "^3.24.0"