@livx.cc/agentx 0.99.109 → 0.99.111

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { o as RouterState, H as Hooks, p as RunResult, R as ReasoningEffort, C as ChannelMode, A as Agent } from './secondChannel-3IPP3Qgh.js';
+import { o as RouterState, H as Hooks, p as RunResult, R as ReasoningEffort, C as ChannelMode, A as Agent } from './secondChannel-CJMY5EbL.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, o as MessageContent } from './tools-DZHZIyxh.js';
 
@@ -375,5 +375,9 @@ declare function runTurn(agent: Agent, store: SessionStore, session: SessionData
 }>;
 /** A failed duplex turn's cause, for the host to show: the provider's message, and for a missing key what to set. */
 declare function duplexError(e: unknown, reflexModel: string): string;
+/** --keep-alive {type:'rollback'}: take back the turn that began at transcript index `start` — its user line, steers and
+ *  (partial) reply leave this session and, on claude-code/*, Claude Code's own history too (rewindClaudeCodeSession) — so
+ *  the next turn (a re-final's fuller text) runs warm, as if that one was never sent. Returns the messages dropped. */
+declare function rollbackTurn(agent: Agent, store: Pick<SessionStore, 'save'>, session: SessionData, start: number): Promise<number>;
 
-export { type PermMode, abortActiveTurn, apiKeysFromEnv, appendMemoryNote, cacheMultipliers, condenseReplay, costOf, duplexError, duplexModels, estimateTranscriptTokens, expandMentions, exportMarkdown, fmtUsd, formatHistory, formatStatus, formatTranscriptFull, jsonResult, loadBodifySecrets, loadInstallEnv, makeHost, mcpMentionResolver, mentionRefs, modelUsable, parseArgs, pastePathClassifier, readImageParts, readMultiline, resolvePermMode, runShellLine, runTurn, setMcpMentionResolver, summarizeResult, turnCost };
+export { type PermMode, abortActiveTurn, apiKeysFromEnv, appendMemoryNote, cacheMultipliers, condenseReplay, costOf, duplexError, duplexModels, estimateTranscriptTokens, expandMentions, exportMarkdown, fmtUsd, formatHistory, formatStatus, formatTranscriptFull, jsonResult, loadBodifySecrets, loadInstallEnv, makeHost, mcpMentionResolver, mentionRefs, modelUsable, parseArgs, pastePathClassifier, readImageParts, readMultiline, resolvePermMode, rollbackTurn, runShellLine, runTurn, setMcpMentionResolver, summarizeResult, turnCost };

package/dist/cli.js

@@ -3432,7 +3432,7 @@ function copyTextToClipboard(text, platform2 = process.platform) {
 
 // cli/cli.ts
 import { join as join16, resolve as resolve5, basename as basename4, extname, dirname as dirname6 } from "path";
-import { AIClient as AIClient2, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions, disposeClaudeCodeSessions } from "ai.libx.js";
+import { AIClient as AIClient2, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions, disposeClaudeCodeSessions, rewindClaudeCodeSession } from "ai.libx.js";
 
 // src/ccBridge.ts
 var CC_BRIDGED = /* @__PURE__ */ new Set(["Recall", "Remember", "MemorySearch", "Forget"]);
@@ -5022,6 +5022,39 @@ var Agent = class _Agent {
    *  steers over its own channel (claude-code's warm InputQueue via `providerOptions.steer`). Non-text
    *  injections (images) stay queued for the step-boundary `drainInjections()` re-open — the text-only
    *  steer channel can't carry them. Consumed DURING chat(); no overlap with drainInjections() (post-call). */
+  /** claude-code/*: the providerOptions every step adds (and prewarm, so the session it starts is the one step 1 reuses). */
+  claudeCodePo() {
+    const o = this.options;
+    if (!o.model.startsWith("claude-code/")) return void 0;
+    const po = { steer: () => this.drainPendingSteers() };
+    const bridged = (t) => o.ccBridge === "all" || CC_BRIDGED.has(t.name);
+    if (o.providerOptions?.claudeCodeSession && this.activeTools.some(bridged)) {
+      this.ccServer ??= ccToolServer("agentx", () => this.activeTools.filter(bridged), (n, a) => this.ccExec(n, a));
+      po.mcpServers = { ...o.providerOptions?.mcpServers, agentx: this.ccServer };
+    }
+    const denyTools = claudeCodeDisallowedTools(o.permissions);
+    if (denyTools.length) {
+      const prior = o.providerOptions?.disallowedTools ?? [];
+      po.disallowedTools = [.../* @__PURE__ */ new Set([...prior, ...denyTools])];
+    }
+    return po;
+  }
+  /** claude-code/* warm session: start it now (its process, MCP handshakes) so the first turn doesn't pay for it. Its
+   *  system prompt is fixed at the start, so it is prepared here (no task hint) — memoized, the turns reuse the same one.
+   *  No model call; the transcript gains only that system message. Other models: nothing to warm. */
+  async prewarm() {
+    const o = this.options;
+    if (!o.model.startsWith("claude-code/") || !o.providerOptions?.claudeCodeSession) return;
+    await this.ensureFs();
+    const systemPrompt = await this.prepare(), startCtx = await this.fireSessionStart();
+    const sys = { role: "system", content: systemPrompt + (startCtx ? "\n\n" + startCtx : "") };
+    if (this.transcript[0]?.role === "system") this.transcript[0] = sys;
+    else this.transcript.unshift(sys);
+    const po = this.claudeCodePo(), frag = reasoningToChatFragment(o.model, o.reasoning);
+    const r = await o.ai.chat({ model: o.model, messages: this.trimContext(), tools: [], stream: true, ...frag, ...o.promptCache ? { promptCache: true } : {}, providerOptions: { ...frag.providerOptions, ...o.providerOptions, ...po, prewarm: true } });
+    for await (const _ of r) {
+    }
+  }
   drainPendingSteers() {
     if (!this.pendingInjections.length) return [];
     const texts = [];
@@ -5314,18 +5347,8 @@ var Agent = class _Agent {
         }
       };
       const cursorPo = isCursorWithTools ? { toolTimeoutMs: effectiveToolTimeoutMs, toolExecutor: hostExec } : void 0;
-      const claudeSteerPo = o.model.startsWith("claude-code/") ? { steer: () => this.drainPendingSteers() } : void 0;
-      const bridged = (t) => o.ccBridge === "all" || CC_BRIDGED.has(t.name);
-      if (claudeSteerPo && o.providerOptions?.claudeCodeSession && this.activeTools.some(bridged)) {
-        this.ccServer ??= ccToolServer("agentx", () => this.activeTools.filter(bridged), (n, a) => this.ccExec(n, a));
-        claudeSteerPo.mcpServers = { ...o.providerOptions?.mcpServers, agentx: this.ccServer };
-      }
+      const claudeSteerPo = this.claudeCodePo();
       if (this.ccServer) this.ccExec = hostExec;
-      const denyTools = o.model.startsWith("claude-code/") ? claudeCodeDisallowedTools(o.permissions) : [];
-      if (denyTools.length) {
-        const prior = o.providerOptions?.disallowedTools ?? [];
-        claudeSteerPo.disallowedTools = [.../* @__PURE__ */ new Set([...prior, ...denyTools])];
-      }
       const cursorDeny = o.model.startsWith("cursor/") ? o.permissions?.denyRules(true) ?? [] : [];
       if (cursorDeny.length)
         throw new Error(`cursor/* cannot enforce --disallowedTools (${cursorDeny.join(", ")}): its native tools bypass them. Refusing to run \u2014 use a claude-code/* or API model, or drop --disallowedTools.`);
@@ -10515,6 +10538,14 @@ ${context.trim()}
 </host_context>
 (Above: context and instructions from the app \u2014 NOT the user's words. Never read it aloud, quote it, or attribute it to the user. The user's line follows.)
 
+`;
+}
+function hostNoteBlock(note) {
+  return `<host_note>
+${note.trim()}
+</host_note>
+(Above: background from the app \u2014 NOT the user's words on this line. Never read it aloud as theirs. The user's line follows.)
+
 `;
 }
 function nowLine() {
@@ -11010,9 +11041,9 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
   /** One reflex model call for a turn; a turn rejected for load (rateLimited) that has not spoken or dispatched yet is rolled
    *  back and re-run once on `reflexFallbackModel` — a re-prompt of the same model (the dead-air nudge) only hits the
    *  same limit and ends in "could you say that again?". */
-  async reflexSend(content, context) {
-    const base = this.voice.transcript.length;
-    const res = await this.sendWithContext(content, context);
+  async reflexSend(content, note) {
+    const base = this.voice.transcript.length, context = this.lastContext;
+    const res = await this.sendWithContext(content, context, note);
     const fb = this.options.reflexFallbackModel, model = this.voice.options.model;
     if (res.finishReason !== "error" || !rateLimited(res.error) || !fb || fb === model || fb.includes("/") && model.includes("/") && fb.split("/")[0] !== model.split("/")[0] || this.turnDispatched || this.turnSpoken.trim()) return res;
     log23.warn(`reflex ${model} rate-limited \u2014 re-running the turn on ${fb}`);
@@ -11020,7 +11051,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     this.voice.transcript.length = base;
     this.voice.options.model = fb;
     try {
-      return await this.sendWithContext(content, context);
+      return await this.sendWithContext(content, context, note);
     } finally {
       this.voice.options.model = model;
     }
@@ -11029,16 +11060,18 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  inside the user turn it read as the user's own words (live #938: "repeat everything I said" recited the call rules). The
    *  stored turn keeps only what the user said, so later turns, briefs and the saved session never carry it. A block, not a
    *  mid-transcript system message: the Anthropic/Google adapters keep only the leading system message. */
-  async sendWithContext(content, context) {
-    if (!context?.trim() || typeof content !== "string") return this.voice.send(content);
-    const base = this.voice.transcript.length;
+  async sendWithContext(content, context, note) {
+    if (typeof content !== "string" || !context?.trim() && !note?.trim()) return this.voice.send(content);
+    const stored = (note?.trim() ? hostNoteBlock(note) : "") + content, base = this.voice.transcript.length;
     try {
-      return await this.voice.send(hostContextBlock(context) + content);
+      return await this.voice.send((context?.trim() ? hostContextBlock(context) : "") + stored);
     } finally {
       const m = this.voice.transcript.slice(base).find((x) => x.role === "user");
-      if (m) m.content = content;
+      if (m) m.content = stored;
     }
   }
+  /** The last line's host context (call rules, browser context): every reflex call runs under it, not only the user's line. */
+  lastContext;
   /** The turn SAID it is on it ("got it — checking…") but called no tool and nothing is running: a promise nothing
    *  keeps — the user waits on silence (live Para #798: a follow-up while the reflex believed a finished task still ran). */
   get hollowPromise() {
@@ -11060,7 +11093,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     this.stepMarks = [];
     this.dropJudge();
     try {
-      await this.voice.send(reminder);
+      await this.sendWithContext(reminder, this.lastContext);
     } catch (e) {
       log23.warn(`follow-through nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
@@ -11203,7 +11236,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     if (this.dispatchAt >= 0) this.dispatchAt = 0;
     this.nudging = true;
     try {
-      await this.voice.send(reminder);
+      await this.sendWithContext(reminder, this.lastContext);
     } catch (e) {
       log23.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
@@ -11242,7 +11275,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  second Act). The host gets `turn_replace` {id, replaces, rolledBack, followed?}: only a rollback drops the replaced
    *  line; `followed` = the kept turn whose follow-up ran (absent: the merged text ran). */
   send(content, opts) {
-    const ctx = opts?.context;
+    const ctx = opts && (opts.context !== void 0 || opts.note !== void 0) ? { context: opts.context, note: opts.note } : void 0;
     this.clearHoldResume();
     this.holdResumed = false;
     if (opts?.replaces) this.replaceTurn(opts.replaces);
@@ -11354,12 +11387,17 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       return { text: "", steps: 0, finishReason: "stop", messages: [] };
     });
   }
-  sendTurn(content, keepParked = false, rec, ext, context) {
+  sendTurn(content, keepParked = false, rec, ext, host) {
     const spec = this.spec;
     if (spec?.state === "pending") {
       if (typeof content === "string" && speculationConfirms(spec.text, content)) {
         spec.state = "confirmed";
         spec.finalText = content;
+        if (host?.context !== void 0) this.lastContext = host.context;
+        if (host?.note?.trim()) {
+          const m = [...this.voice.transcript].reverse().find((x) => x.role === "user" && x.content === spec.text);
+          if (m) m.content = hostNoteBlock(host.note) + spec.text;
+        }
         if (rec) {
           spec.rec = rec;
           rec.ctl.signal.addEventListener("abort", () => spec.ctl.abort(), { once: true });
@@ -11406,8 +11444,9 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       }
       if (typeof content === "string") content += spellingNote(content);
       let res;
+      if (host?.context !== void 0) this.lastContext = host.context;
       try {
-        res = await this.reflexSend(content, context);
+        res = await this.reflexSend(content, host?.note);
       } finally {
         if (signal) {
           this.voice.options.signal = ext;
@@ -11456,7 +11495,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       this.voice.options.signal = spec.ctl.signal;
       let res;
       try {
-        res = await this.voice.send(spec.text);
+        res = await this.sendWithContext(spec.text, this.lastContext);
       } catch (e) {
         log23.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
@@ -11735,7 +11774,7 @@ Update: ${brief}`;
     return this.voice.transcript.filter((m) => (m.role === "user" || m.role === "assistant") && contentText(m.content).trim()).slice(-turns).map((m) => `${m.role}: ${contentText(m.content)}`).join("\n");
   }
   buildBrief(brief, tier = "act", deliver = true) {
-    const recent = this.recentExcerpt();
+    const recent = this.recentExcerpt(), host = this.lastContext?.trim();
     const verify = tier === "act" ? "\n\nBefore reporting done: re-read what you changed and check it against EVERY requirement above \u2014 fix any gap first. Your report is trusted without review. A command exiting 0 or echoing its input means it was ACCEPTED, not that it worked: before you say a web address was opened or reached, confirm it exists (its host resolves in DNS and answers an HTTP request); if it does not, report that it does not exist instead of success, and name the address you tried." : "";
     const deliverContract = deliver ? '\n\n## DELIVER (spoken delivery)\nYou are reporting back to a user who is LISTENING. Stream your work normally \u2014 your prose is the written work record and detail, and is NOT spoken. Wrap anything the user should HEAR in <spoken>\u2026</spoken> tags. LEAD WITH the actual content they asked for: if they asked for a specific piece of content \u2014 a value, a name, the actual lines, the writing itself \u2014 that content goes INSIDE the <spoken> tags, not a remark about it. Your FIRST <spoken> segment is substantive \u2014 never a greeting or an acknowledgement (the front-end has already acked; do not double-ack). Keep spoken text concise and natural for the ear: short sentences, no markdown. Never read a file path, URL, command or code aloud, nor spell one out ("slash \u2026 slash \u2026") \u2014 say it the way a person would, by the name of the folder, project, file or site; the exact text stays in your written prose. ' + (this.options.spokenBudgetChars ? `Speak a SHORT summary only: at most three short sentences with the one thing that matters most, then ONE short offer that names what else you have, as a question they can answer in a word \u2014 under ${this.options.spokenBudgetChars} characters in all, the offer included. Everything else stays in your written prose (it is kept and they can ask for it); spoken text past that budget is cut and held until they ask. ` : "") + `NEVER enumerate in speech \u2014 no numbered or bulleted lists ("One. \u2026 Two. \u2026" is robotic). Deliver multiple items as flowing conversation with brief connective phrasing ("here's one\u2026", "and another\u2026", "oh, and\u2026"), pausing between items with sentence breaks, not numbers.` + (this.options.emotionTags ? " Inside <spoken>, you may prefix a sentence with an inline [emotion] tag (e.g. [excited], [curious]) to color how it is voiced \u2014 only when it genuinely fits, and vary it; [laughter] gives a natural laugh." : "") : "";
     return `${nowLine()}.
@@ -11743,7 +11782,10 @@ Update: ${brief}`;
 ` + (recent ? `${brief}
 
 ## Recent conversation (for context)
-${recent}` : brief) + verify + deliverContract;
+${recent}` : brief) + (host ? `
+
+## The app's context for this line (not the user's words)
+${host}` : "") + verify + deliverContract;
   }
   /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
   spawnWorker(id, label, briefText, tier, brief, followUp) {
@@ -18812,11 +18854,16 @@ Flags:
   --timeout <sec>      wall-clock kill-switch (default 120)
   --input-format stream-json  with --duplex|--voice + --output-format stream-json: headless duplex for a host app
                        (NDJSON turns/barge-ins on stdin, reflex text + worker speech + task events on stdout)
+                       a user line's {context, note} = host info fenced as the app's (context: per-line rules, kept for
+                       results/reminders; note: persistent background) \u2014 never stored as the user's words
                        with -p: the first {"type":"user","text"} line is the prompt; later ones STEER the running turn
                        (unconsumed steers come back as the result's \`unsteered\`)
   --keep-alive         with -p --input-format stream-json: stay up after a turn \u2014 each {"type":"user"} line while idle
                        is the NEXT turn (warm: same session, model connection and MCP servers), one {type:result}
-                       per turn; {"type":"abort"} stops the running turn; stdin EOF exits
+                       per turn; it boots (and warms a claude-code/* session) before the first line arrives;
+                       {"type":"abort"} stops the running turn (the next one is still warm); {"type":"rollback"}
+                       takes the last turn back (stopping it if running) \u2014 its user line and reply leave the
+                       session, Claude Code's own history included; stdin EOF exits
   --output-format <f>  headless output: text (default) | json (one result object) | stream-json (NDJSON events: {type:text|thinking}\u2026 then {type:result})
   -v, --version        print version and exit
   -h, --help
@@ -22520,7 +22567,7 @@ async function duplexServe(args, ai, cfg, cwd) {
         const done2 = () => {
           if (seq === scTurn) sc?.onAgentState("idle");
         };
-        void runTurn(dx.voice, store, session, m.text + note, void 0, cwd, (c) => dx.send(c, { id, replaces: m.replaces ? String(m.replaces) : void 0, followUp: typeof m.followUp === "string" || m.followUp && typeof m.followUp === "object" ? m.followUp : void 0, context: typeof m.context === "string" ? m.context : void 0 })).then(({ res, error }) => {
+        void runTurn(dx.voice, store, session, m.text + note, void 0, cwd, (c) => dx.send(c, { id, replaces: m.replaces ? String(m.replaces) : void 0, followUp: typeof m.followUp === "string" || m.followUp && typeof m.followUp === "object" ? m.followUp : void 0, context: typeof m.context === "string" ? m.context : void 0, note: typeof m.note === "string" ? m.note : void 0 })).then(({ res, error }) => {
           const why = (res?.finishReason ?? "error") === "error" ? duplexError(res?.error ?? error, dx.options.reflexModel) : "";
           done2();
           out({ type: "turn_done", id, finishReason: res?.finishReason ?? "error", ...why ? { error: why } : {} });
@@ -22583,7 +22630,7 @@ async function channelServe(args, ai, cfg) {
 }
 function readStdinSteers(keepAlive = false) {
   const early = [];
-  let sink, got, closed = false;
+  let sink, got, closed = false, started = false;
   const first = new Promise((res) => {
     got = res;
   });
@@ -22599,7 +22646,17 @@ function readStdinSteers(keepAlive = false) {
       activeTurn?.abort();
       return;
     }
+    if (keepAlive && m?.type === "rollback") {
+      if (!started) return;
+      activeTurn?.abort();
+      if (got) {
+        got({ type: "rollback" });
+        got = void 0;
+      } else early.push({ type: "rollback" });
+      return;
+    }
     if (m?.type !== "user" || typeof m.text !== "string" || !m.text.trim()) return;
+    started = true;
     if (got) {
       got(m.text);
       got = void 0;
@@ -22619,9 +22676,21 @@ function readStdinSteers(keepAlive = false) {
   };
   return { first, steer: (to) => {
     sink = to;
-    early.splice(0).forEach(to);
+    while (typeof early[0] === "string") to(early.shift());
   }, next };
 }
+async function rollbackTurn(agent, store, session, start) {
+  if (start < 0 || start > agent.transcript.length) return 0;
+  const dropped = agent.transcript.length - start;
+  agent.transcript.splice(start);
+  session.messages = agent.transcript;
+  session.meta.updated = Date.now();
+  session.meta.cc = void 0;
+  const cc = agent.options.providerOptions?.claudeCodeSession;
+  if (typeof cc === "string" && agent.options.model.startsWith("claude-code/")) await rewindClaudeCodeSession(cc);
+  store.save(session);
+  return dropped;
+}
 function readAllStdin() {
   return new Promise((res) => {
     let data = "";
@@ -22656,9 +22725,11 @@ async function main() {
   }
   if (args.debug) process.env.DEBUG ||= "*";
   const steers = args.print && args.inputFormat && !args.task ? readStdinSteers(args.keepAlive) : void 0;
-  if (steers) args.task = (await steers.first).trim();
-  else if (args.print && !args.task && !process.stdin.isTTY) args.task = (await readAllStdin()).trim();
-  if (args.print && !args.task) {
+  const warmBoot = !!(steers && args.keepAlive);
+  if (steers && !warmBoot) args.task = (await steers.first).trim();
+  else if (warmBoot) {
+  } else if (args.print && !args.task && !process.stdin.isTTY) args.task = (await readAllStdin()).trim();
+  if (args.print && !args.task && !warmBoot) {
     console.error(red("  -p: empty prompt (no task argument and nothing on stdin)"));
     process.exit(2);
   }
@@ -22725,8 +22796,8 @@ async function main() {
       }
     }
   });
-  if (args.task) {
-    const compactArg = /^\/compact(?:\s+([\s\S]*))?$/.exec(args.task.trim());
+  if (args.task || warmBoot) {
+    const compactArg = /^\/compact(?:\s+([\s\S]*))?$/.exec((args.task ?? "").trim());
     if (compactArg) {
       const agent2 = await makeAgent(args, ai, cfg, [], []), store2 = new SessionStore(cwd), session2 = startSession(args, store2, agent2, cwd);
       const est = (m) => estimateTranscriptTokens(m, agent2.options.keepRecentImages, agent2.options.imageInput?.(agent2.options.model) !== false);
@@ -22749,8 +22820,22 @@ async function main() {
     process.once("SIGINT", () => activeTurn?.abort());
     steers?.steer((text) => agent.inject(text));
     const turn = (task) => runTurn(agent, store, session, task, void 0, cwd, autoRouteSend(args, agent, () => session, (m) => providerOptionsFor(m, cwd, cfg.mcpServers, mounted.map((x) => x.name))));
-    if (args.keepAlive && steers) {
-      for (let task = args.task; task.trim(); task = (await steers.next()).trim()) {
+    if (warmBoot && steers) {
+      bindClaudeCodeSession(agent, session);
+      await agent.prewarm().catch((e) => err(dim(`  (prewarm failed: ${e?.message ?? e})
+`)));
+      let start = -1;
+      for (let line = await steers.first; ; line = await steers.next()) {
+        if (typeof line !== "string") {
+          const n = await rollbackTurn(agent, store, session, start);
+          start = -1;
+          err(dim(`  \u21B6 rolled back the last turn (${n} message${n === 1 ? "" : "s"})
+`));
+          continue;
+        }
+        const task = line.trim();
+        if (!task) break;
+        start = agent.transcript.length;
         steers.steer((text) => agent.inject(text));
         const { res: res2 } = await turn(task);
         const left = agent.drainPendingSteers();
@@ -22820,6 +22905,7 @@ export {
   readImageParts,
   readMultiline,
   resolvePermMode,
+  rollbackTurn,
   runShellLine,
   runTurn,
   setMcpMentionResolver,