turbollm 1.8.6 → 1.8.7

package/dist/cli.js

@@ -6199,6 +6199,30 @@ var ConversationStore = class {
     if (!from) return 0;
     return this.db.prepare(`UPDATE messages SET is_active = 1 WHERE conv_id = $cid AND seq >= $seq`).run({ $cid: convId, $seq: from.seq }).changes;
   }
+  /** /clear (v34): deactivates `uptoMessageId` and every message BEFORE it (by `seq`) — a real,
+   *  resumable PREFIX deactivation (is_active=0), the mirror of {@link deactivateMessagesFrom}'s
+   *  suffix and the same mechanism /revert and Chat branching use. Replaces /clear's old
+   *  clearedUpToMessageId DISPLAY cursor, which left the "cleared" rows is_active=1 — so
+   *  getMessages()/getConversation() (hence session export AND the model's own history replay via
+   *  resolveEffectiveHistory) still saw them, applying the cut only client-side. /clear hides
+   *  everything up to AND INCLUDING the cut (showing only turns added AFTER it), so this is a
+   *  prefix. Returns the number of rows deactivated (0 if `uptoMessageId` doesn't exist). Only ever
+   *  called on Code conversations, which have no regenerate/branch siblings, so every prefix row is
+   *  active at clear time — same coarse assumption reactivateMessagesFrom already relies on. */
+  deactivateMessagesUpTo(convId, uptoMessageId) {
+    const upto = this.db.prepare(`SELECT seq FROM messages WHERE id = $id AND conv_id = $cid`).get({ $id: uptoMessageId, $cid: convId });
+    if (!upto) return 0;
+    return this.db.prepare(`UPDATE messages SET is_active = 0 WHERE conv_id = $cid AND seq <= $seq`).run({ $cid: convId, $seq: upto.seq }).changes;
+  }
+  /** Undoes {@link deactivateMessagesUpTo} — reactivates `uptoMessageId` and every message before
+   *  it (by `seq`). A NEW turn appended after a /clear has a HIGHER seq than the cut, so /resume
+   *  never touches it — only the originally-cleared prefix comes back. Safe if `uptoMessageId` no
+   *  longer exists (0 rows). */
+  reactivateMessagesUpTo(convId, uptoMessageId) {
+    const upto = this.db.prepare(`SELECT seq FROM messages WHERE id = $id AND conv_id = $cid`).get({ $id: uptoMessageId, $cid: convId });
+    if (!upto) return 0;
+    return this.db.prepare(`UPDATE messages SET is_active = 1 WHERE conv_id = $cid AND seq <= $seq`).run({ $cid: convId, $seq: upto.seq }).changes;
+  }
   /** Permanently delete a Code session: its messages, working doc, and the agent_run +
    *  conversation rows. There is no FK cascade on these tables (each is deleted explicitly,
    *  same as chat's own conversation delete never cascaded to messages) — miss one and it's
@@ -14098,18 +14122,18 @@ function registerApi(app2, d) {
     if (!existsSync22(cwd) || !statSync5(cwd).isDirectory()) {
       return c.json({ isRepo: false, branch: "", branches: [] });
     }
-    const git = (args) => execFileSync5("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3, windowsHide: true }).trim();
+    const git2 = (args) => execFileSync5("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3, windowsHide: true }).trim();
     try {
-      if (git(["rev-parse", "--is-inside-work-tree"]) !== "true") return c.json({ isRepo: false, branch: "", branches: [] });
+      if (git2(["rev-parse", "--is-inside-work-tree"]) !== "true") return c.json({ isRepo: false, branch: "", branches: [] });
       let branch = "";
       try {
-        branch = git(["rev-parse", "--abbrev-ref", "HEAD"]);
+        branch = git2(["rev-parse", "--abbrev-ref", "HEAD"]);
       } catch {
       }
       if (branch === "HEAD") branch = "";
       let branches = [];
       try {
-        branches = git(["branch", "--format=%(refname:short)"]).split("\n").map((s) => s.trim()).filter(Boolean);
+        branches = git2(["branch", "--format=%(refname:short)"]).split("\n").map((s) => s.trim()).filter(Boolean);
       } catch {
       }
       return c.json({ isRepo: true, branch, branches });
@@ -15808,6 +15832,16 @@ function dependencyDisciplineGuidance() {
     "training knowledge, which is frequently stale for fast-moving libraries."
   ].join(" ");
 }
+function todoTrackerGuidance() {
+  return [
+    "For a task with several distinct steps, call update_todos to give the user a live checklist:",
+    "send the full list of steps (each { content, status }) when you start, mark a step in_progress",
+    "when you begin it and completed as soon as it is done, and re-send the WHOLE list on every",
+    "update (it replaces the previous one). This shows the user the plan and real progress instead",
+    "of an opaque run of tool calls. Do NOT use it for trivial single-step requests \u2014 a one-item",
+    "checklist is just noise."
+  ].join(" ");
+}
 function toolsForMode(mode) {
   return mode === "plan" ? ["read", "grep", "find", "ls"] : void 0;
 }
@@ -15839,6 +15873,12 @@ function readAgentsFile(path) {
     return null;
   }
 }
+function agentsMdPresence(repoRoot, globalDir) {
+  return {
+    project: readAgentsFile(join27(repoRoot, "AGENTS.md")) !== null,
+    global: readAgentsFile(join27(globalDir, "agents.md")) !== null
+  };
+}
 function agentsMdBlock(repoRoot, globalDir) {
   const global = readAgentsFile(join27(globalDir, "agents.md"));
   const project = readAgentsFile(join27(repoRoot, "AGENTS.md"));
@@ -15857,6 +15897,7 @@ function buildAppendPrompt(mode, skills = [], agentsMd, hasWebTools = false) {
   if (mode !== "plan") {
     blocks.push(editReliabilityGuidance());
     blocks.push(lspGuidance());
+    blocks.push(todoTrackerGuidance());
   }
   if (hasWebTools) {
     blocks.push(antiFallbackGuidance());
@@ -16128,12 +16169,9 @@ var COMPACTION_SUFFIX = "\n\n(End of summary \u2014 the actual conversation cont
 function resolveEffectiveHistory(d, convId, sessionId) {
   const all = d.db.getConversation(convId, true)?.messages ?? [];
   const run = d.db.getAgentRun(sessionId);
-  const compactionIdx = run?.compactionUpToMessageId ? all.findIndex((m) => m.id === run.compactionUpToMessageId) : -1;
-  const clearedIdx = run?.clearedUpToMessageId ? all.findIndex((m) => m.id === run.clearedUpToMessageId) : -1;
-  if (clearedIdx !== -1 && clearedIdx >= compactionIdx) {
-    return { summaryText: null, messages: all.slice(clearedIdx + 1) };
-  }
+  if (run?.clearedUpToMessageId) return { summaryText: null, messages: all };
   if (!run?.compactionUpToMessageId) return { summaryText: null, messages: all };
+  const compactionIdx = all.findIndex((m) => m.id === run.compactionUpToMessageId);
   const rest = compactionIdx === -1 ? all : all.slice(compactionIdx + 1);
   return { summaryText: `${COMPACTION_PREFIX}${run.compactionSummary}${COMPACTION_SUFFIX}`, messages: rest };
 }
@@ -16162,6 +16200,7 @@ function keepRecentTokensFor(messages, baseKeepRecentTokens) {
 var MUTATING_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "bash"]);
 var PATH_TOOLS = /* @__PURE__ */ new Set(["read", "edit", "write", "grep", "find", "ls"]);
 var LOOP_BREAK_AFTER = 3;
+var LOOP_ABORT_AFTER = LOOP_BREAK_AFTER + 3;
 function toolCallSignature(name, input) {
   const stable = (v) => {
     if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "undefined";
@@ -16210,6 +16249,99 @@ function disposeLspClientsForConv(convId) {
   for (const c of clients.values()) c.dispose();
   lspClientsByConv.delete(convId);
 }
+function extractPartialText(partialResult) {
+  const pr = partialResult;
+  if (!pr || !Array.isArray(pr.content)) return "";
+  return pr.content.map((c) => c?.type === "text" ? c.text ?? "" : "").join("");
+}
+function codeEventToFrame(ev, turnCounter) {
+  switch (ev.type) {
+    case "message_update": {
+      const ame = ev.assistantMessageEvent;
+      if (ame.type === "text_delta") return { event: "delta", data: { delta: ame.delta } };
+      if (ame.type === "thinking_delta") return { event: "reasoning", data: { delta: ame.delta } };
+      return null;
+    }
+    case "compaction_start":
+      return { event: "compaction", data: { phase: "start", reason: ev.reason } };
+    case "compaction_end":
+      return { event: "compaction", data: { phase: "end", reason: ev.reason, aborted: ev.aborted, tokensBefore: ev.result?.tokensBefore } };
+    case "turn_start":
+      return { event: "turn", data: { phase: "start", index: turnCounter.index } };
+    case "turn_end": {
+      const frame = { event: "turn", data: { phase: "end", index: turnCounter.index, toolResults: ev.toolResults.length } };
+      turnCounter.index++;
+      return frame;
+    }
+    case "auto_retry_start":
+      return { event: "retry", data: { phase: "start", attempt: ev.attempt, maxAttempts: ev.maxAttempts, delayMs: ev.delayMs, message: ev.errorMessage } };
+    case "auto_retry_end":
+      return { event: "retry", data: { phase: "end", attempt: ev.attempt, success: ev.success, message: ev.finalError } };
+    case "tool_execution_update":
+      return { event: "tool_progress", data: { id: ev.toolCallId, name: ev.toolName, partial: extractPartialText(ev.partialResult) } };
+    default:
+      return null;
+  }
+}
+var DELEGATE_SUBAGENT_TIMEOUT_MS = 5 * 6e4;
+function validateDelegateTask(raw) {
+  const task = typeof raw === "string" ? raw.trim() : "";
+  if (!task) return { ok: false, message: "delegate_task: `task` must be a non-empty description of the sub-task to delegate." };
+  return { ok: true, task };
+}
+function normalizeDelegateResult(finalText, opts) {
+  const text = finalText.trim();
+  if (opts?.timedOut) {
+    const mins = Math.max(1, Math.round((opts.timeoutMs ?? DELEGATE_SUBAGENT_TIMEOUT_MS) / 6e4));
+    const partial = text ? `
+
+Partial progress before it was stopped:
+${text}` : "";
+    return `(the delegated sub-task did not finish within ~${mins} minute(s) and was stopped \u2014 treat it as INCOMPLETE; consider doing it yourself or delegating a smaller piece.${partial})`;
+  }
+  return text || "(the delegated sub-agent produced no output.)";
+}
+var DELEGATED_SUBAGENT_PREAMBLE = "You are an isolated sub-agent handling ONE delegated sub-task on behalf of a parent coding agent. You do NOT see the parent conversation or its history \u2014 everything you need is in the task message below. Do exactly that task and nothing more, using your tools against the same repository. You cannot delegate further or invoke skills. When finished, end your reply with a concise, self-contained summary of what you did, what you found, and anything the parent needs in order to continue \u2014 that summary is the ONLY thing returned to the parent.";
+var TODO_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
+var MAX_TODOS = 50;
+function normalizeTodos(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const rec = item;
+    const content = typeof rec.content === "string" ? rec.content.trim() : "";
+    if (!content) continue;
+    const status = typeof rec.status === "string" && TODO_STATUSES.has(rec.status) ? rec.status : "pending";
+    out.push({ content, status });
+    if (out.length >= MAX_TODOS) break;
+  }
+  return out;
+}
+function summarizeTodos(todos) {
+  if (todos.length === 0) return "Todo list cleared.";
+  const completed = todos.filter((t) => t.status === "completed").length;
+  const inProgress = todos.filter((t) => t.status === "in_progress").length;
+  const parts = [`${completed}/${todos.length} done`];
+  if (inProgress > 0) parts.push(`${inProgress} in progress`);
+  return `Tracking ${todos.length} step(s): ${parts.join(", ")}.`;
+}
+var PREFILL_POLL_MS = 300;
+function isProcessingSlot(s) {
+  if (!s || typeof s !== "object") return false;
+  const r = s;
+  return r.is_processing === true && typeof r.n_prompt_tokens === "number" && typeof r.n_prompt_tokens_processed === "number";
+}
+function pickPrefillProgress(slots) {
+  if (!Array.isArray(slots)) return null;
+  const processing = slots.filter(isProcessingSlot);
+  if (processing.length !== 1) return null;
+  const total = processing[0].n_prompt_tokens;
+  const processed = processing[0].n_prompt_tokens_processed;
+  if (!(total > 0) || processed < 0) return null;
+  const pct = Math.min(100, Math.max(0, Math.round(processed / total * 100)));
+  return { processed, total, pct };
+}
 async function runCodeSession(params) {
   const { d, convId, sessionId, repoRoot, mode, thinkingBudget, task: rawTask, signal, sink } = params;
   const ms = d.manager.status();
@@ -16409,12 +16541,192 @@ async function runCodeSession(params) {
     skillSession.dispose();
     return finalText2.trim() || "(the skill produced no output)";
   }
+  async function runDelegatedSubSession(subMode, task2) {
+    const subAuth = AuthStorage.inMemory();
+    const subRegistry = ModelRegistry.inMemory(subAuth);
+    subRegistry.registerProvider("local", {
+      baseUrl: `${target}/v1`,
+      apiKey: "agent-key",
+      authHeader: true,
+      api: "openai-completions",
+      models: [{
+        id: modelId,
+        name: modelDisplayName,
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow,
+        maxTokens: 8192,
+        compat: { supportsDeveloperRole: false, thinkingFormat: "qwen-chat-template" }
+      }]
+    });
+    const subModel = subRegistry.find("local", modelId);
+    if (!subModel) throw new Error("Failed to register local model with pi.");
+    const subAc = new AbortController();
+    let timedOut = false;
+    const onParentAbort = () => subAc.abort();
+    if (signal.aborted) subAc.abort();
+    else signal.addEventListener("abort", onParentAbort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      subAc.abort();
+    }, DELEGATE_SUBAGENT_TIMEOUT_MS);
+    let subHeldGate;
+    const releaseSubGate = () => {
+      const r = subHeldGate;
+      subHeldGate = void 0;
+      r?.();
+    };
+    const subExtension = (pi) => {
+      pi.on("before_provider_request", async (event) => {
+        releaseSubGate();
+        if (d.gate) subHeldGate = await d.gate.acquire("bg", { signal: subAc.signal });
+        const payload = { ...event.payload };
+        delete payload.max_tokens;
+        delete payload.max_completion_tokens;
+        return payload;
+      });
+      pi.on("after_provider_response", () => {
+        releaseSubGate();
+      });
+      pi.on("tool_call", async (event) => {
+        const toolName = event.toolName;
+        const toolCallId = event.toolCallId;
+        const input = event.input;
+        await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "pending" } });
+        if (PATH_TOOLS.has(toolName)) {
+          const p = input.path;
+          const pathRequired = toolName === "read" || toolName === "edit" || toolName === "write";
+          if (p !== void 0 && typeof p === "string") {
+            if (!isContainedFromRoot(p, repoRoot)) {
+              const reason = "path is outside the allowed repo root";
+              await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "error", result: reason } });
+              return { block: true, reason };
+            }
+          } else if (pathRequired) {
+            const reason = `${toolName}: a valid path is required`;
+            await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "error", result: reason } });
+            return { block: true, reason };
+          }
+        }
+        if (subMode === "ask" && MUTATING_TOOLS.has(toolName)) {
+          await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "awaiting_approval" } });
+          const decision = await waitForToolApproval(`${convId}:${toolCallId}`, subAc.signal);
+          if (decision === "deny") {
+            const reason = "denied by user";
+            await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "error", result: reason } });
+            return { block: true, reason };
+          }
+        }
+        return;
+      });
+      pi.on("tool_result", async (event) => {
+        const text = event.content.map((c) => c.type === "text" ? c.text : "").join("");
+        const data = {
+          id: event.toolCallId,
+          name: event.toolName,
+          args: event.input,
+          status: event.isError ? "error" : "done",
+          result: text
+        };
+        if (isEditToolResult(event) && event.details) {
+          data.diff = event.details.diff;
+          data.patch = event.details.patch;
+          data.firstChangedLine = event.details.firstChangedLine;
+        }
+        await sink({ event: "tool_call", data });
+      });
+    };
+    const subAgentDir = join28(d.store.dir(), "pi-agent");
+    const subResourceLoader = new DefaultResourceLoader({
+      cwd: repoRoot,
+      agentDir: subAgentDir,
+      settingsManager: SettingsManager.inMemory(),
+      extensionFactories: [{ name: "turbollm-delegate", factory: subExtension }],
+      // The normal mode persona (no skill catalog — a delegated sub-agent can't invoke skills),
+      // plus the delegation preamble that frames it as a focused, summary-returning worker.
+      appendSystemPrompt: [...buildAppendPrompt(subMode, [], { repoRoot, globalDir: d.store.dir() }, !!d.tools), DELEGATED_SUBAGENT_PREAMBLE],
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true
+    });
+    await subResourceLoader.reload();
+    const subTools = toolsForMode(subMode);
+    const subBash = createBashTool(repoRoot, { operations: createRobustBashOperations({ sessionLabel: `${sessionId}:delegate` }) });
+    const { session: subSession } = await createAgentSession({
+      cwd: repoRoot,
+      agentDir: subAgentDir,
+      model: subModel,
+      authStorage: subAuth,
+      modelRegistry: subRegistry,
+      resourceLoader: subResourceLoader,
+      sessionManager: SessionManager.inMemory(repoRoot),
+      settingsManager: SettingsManager.inMemory({ compaction: compactionSettingsFor(contextWindow) }),
+      customTools: [subBash],
+      ...subTools ? { tools: subTools } : {}
+      // No invoke_skill / delegate_task / web / mcp / lsp tools registered → depth-1, bounded set.
+    });
+    const onSubAbort = () => {
+      void subSession.abort();
+    };
+    if (subAc.signal.aborted) onSubAbort();
+    else subAc.signal.addEventListener("abort", onSubAbort, { once: true });
+    try {
+      await subSession.prompt(task2);
+    } catch (e) {
+      if (!timedOut && !subAc.signal.aborted) throw e;
+    } finally {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onParentAbort);
+      releaseSubGate();
+    }
+    const finalText2 = subSession.getLastAssistantText() ?? "";
+    subSession.dispose();
+    return normalizeDelegateResult(finalText2, timedOut ? { timedOut: true, timeoutMs: DELEGATE_SUBAGENT_TIMEOUT_MS } : void 0);
+  }
   const mcpToolDefs = d.tools ? (await d.tools.buildToolDefinitions()).filter((t) => t.function.name.startsWith("mcp__")) : [];
   const mcpToolNames = new Set(mcpToolDefs.map((t) => t.function.name));
+  let prefillTimer;
+  let prefillActive = false;
+  const stopPrefillPoll = () => {
+    prefillActive = false;
+    if (prefillTimer) {
+      clearTimeout(prefillTimer);
+      prefillTimer = void 0;
+    }
+  };
+  const startPrefillPoll = () => {
+    stopPrefillPoll();
+    prefillActive = true;
+    let lastPct = -1;
+    const tick2 = async () => {
+      if (!prefillActive) return;
+      try {
+        const res = await fetch(`${target}/slots`, { signal });
+        if (res.ok) {
+          const progress = pickPrefillProgress(await res.json());
+          if (progress && prefillActive) {
+            if (progress.pct !== lastPct) {
+              lastPct = progress.pct;
+              void sink({ event: "prefill", data: { ...progress } });
+            }
+            if (progress.processed >= progress.total) {
+              stopPrefillPoll();
+              return;
+            }
+          }
+        }
+      } catch {
+      }
+      if (prefillActive) prefillTimer = setTimeout(() => void tick2(), PREFILL_POLL_MS);
+    };
+    prefillTimer = setTimeout(() => void tick2(), PREFILL_POLL_MS);
+  };
   const extension = (pi) => {
     pi.on("before_provider_request", async (event) => {
       releaseGate();
       if (d.gate) heldGate = await d.gate.acquire("bg", { signal });
+      startPrefillPoll();
       const payload = { ...event.payload };
       delete payload.max_tokens;
       delete payload.max_completion_tokens;
@@ -16431,6 +16743,7 @@ async function runCodeSession(params) {
       return payload;
     });
     pi.on("after_provider_response", () => {
+      stopPrefillPoll();
       releaseGate();
     });
     pi.on("tool_call", async (event) => {
@@ -16438,7 +16751,14 @@ async function runCodeSession(params) {
       const toolCallId = event.toolCallId;
       const input = event.input;
       await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "pending" } });
-      if (toolLoop.record(toolName, input) > LOOP_BREAK_AFTER) {
+      const loopCount = toolLoop.record(toolName, input);
+      if (loopCount > LOOP_ABORT_AFTER) {
+        const reason = `[SYSTEM: \`${toolName}\` was called with identical arguments ${loopCount} times in a row, including after being told to stop \u2014 this run has been stopped automatically rather than continue looping. Start a new turn with different instructions to try again.]`;
+        await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "error", result: reason } });
+        void session.abort();
+        return { block: true, reason };
+      }
+      if (loopCount > LOOP_BREAK_AFTER) {
         const reason = `[SYSTEM: you have called \`${toolName}\` with identical arguments too many times in a row and it is not making progress \u2014 this call was NOT executed. Stop repeating it: take a different action, call it with different arguments, or, if you already have what you need, give your final answer now.]`;
         await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "error", result: reason } });
         return { block: true, reason };
@@ -16561,6 +16881,50 @@ ${lines.join("\n")}${more}]`
         }
       }
     });
+    pi.registerTool({
+      name: "delegate_task",
+      label: "Delegate task",
+      description: `Delegate a focused, self-contained sub-task to an isolated sub-agent that has your same repository access and tools (subject to the current mode), runs it to completion, and returns ONLY its final summary \u2014 the sub-agent's step-by-step work never enters this conversation, so your own context stays focused. Use it for a well-scoped chunk you can describe completely up front (e.g. "investigate how X works and report back", or "apply this specific refactor across these files"). The sub-agent does NOT see this conversation, so put everything it needs in the task; it cannot delegate further or invoke skills.`,
+      promptSnippet: "delegate_task(task) - hand a focused, fully-described sub-task to an isolated sub-agent and get back its summary",
+      parameters: Type.Object({
+        task: Type.String({ description: "The complete, self-contained sub-task, including every bit of context the sub-agent needs (it does not see this conversation or its history)." })
+      }),
+      async execute(_toolCallId, params2) {
+        const valid = validateDelegateTask(params2.task);
+        if (!valid.ok) return { content: [{ type: "text", text: valid.message }], details: {} };
+        const dbMode = d.db.getConversation(convId)?.agentMode ?? mode;
+        const liveMode = dbMode === "plan" ? mode : dbMode;
+        try {
+          const text = await runDelegatedSubSession(liveMode, valid.task);
+          return { content: [{ type: "text", text }], details: {} };
+        } catch (e) {
+          return { content: [{ type: "text", text: `delegate_task: failed (${e instanceof Error ? e.message : String(e)}) \u2014 try again, or do the task yourself.` }], details: {} };
+        }
+      }
+    });
+    pi.registerTool({
+      name: "update_todos",
+      label: "Update todos",
+      description: "Maintain a visible checklist of the steps for a multi-step task so the user can see your plan and live progress. Call it when you START a task that has several distinct steps (send the full list, each step pending), and again whenever a step's state changes: mark a step in_progress when you begin it and completed as soon as it is done. ALWAYS send the ENTIRE current list each call \u2014 it REPLACES the previous one, it is not a diff. Skip it for trivial single-step requests; a one-item checklist is just noise.",
+      promptSnippet: "update_todos(todos) - show/refresh a checklist of steps for a multi-step task (send the whole list each call)",
+      parameters: Type.Object({
+        todos: Type.Array(
+          Type.Object({
+            content: Type.String({ description: 'The step as a short imperative phrase, e.g. "Add the /export route".' }),
+            status: Type.Union(
+              [Type.Literal("pending"), Type.Literal("in_progress"), Type.Literal("completed")],
+              { description: "pending, in_progress, or completed." }
+            )
+          }),
+          { description: "The COMPLETE current step list, in order \u2014 replaces the previous list entirely." }
+        )
+      }),
+      async execute(_toolCallId, params2) {
+        const todos = normalizeTodos(params2.todos);
+        await sink({ event: "todos", data: { todos } });
+        return { content: [{ type: "text", text: summarizeTodos(todos) }], details: {} };
+      }
+    });
     if (d.tools) {
       const tools2 = d.tools;
       pi.registerTool({
@@ -16680,24 +17044,24 @@ ${lines.join("\n")}${more}]`
   };
   if (signal.aborted) onAbort();
   else signal.addEventListener("abort", onAbort, { once: true });
+  const turnCounter = { index: 0 };
   const unsubscribe = session.subscribe((ev) => {
-    if (ev.type === "message_update") {
-      const ame = ev.assistantMessageEvent;
-      if (ame.type === "text_delta") {
-        void sink({ event: "delta", data: { delta: ame.delta } });
-      } else if (ame.type === "thinking_delta") {
-        void sink({ event: "reasoning", data: { delta: ame.delta } });
-      }
-    } else if (ev.type === "compaction_start") {
-      void sink({ event: "compaction", data: { phase: "start", reason: ev.reason } });
-    } else if (ev.type === "compaction_end") {
-      void sink({ event: "compaction", data: { phase: "end", reason: ev.reason, aborted: ev.aborted, tokensBefore: ev.result?.tokensBefore } });
-    }
+    if (ev.type === "message_update") stopPrefillPoll();
+    const frame = codeEventToFrame(ev, turnCounter);
+    if (frame) void sink(frame);
   });
+  const steerHandle = async (text) => {
+    if (!session.isStreaming) return false;
+    await session.steer(text);
+    return true;
+  };
   d.manager.generationStart();
+  params.onSteerable?.(steerHandle);
   try {
     await session.prompt(task);
   } finally {
+    params.onSteerable?.(null);
+    stopPrefillPoll();
     unsubscribe();
     releaseGate();
     d.manager.generationEnd();
@@ -16857,7 +17221,12 @@ var CodeRunManager = class {
    *  (not just index) identifies each entry so a per-chip action (sendNow) can target one
    *  specific queued turn even if two queued tasks have identical text. */
   queued(sessionId) {
-    return this.sessions.get(sessionId)?.queue.map((t) => ({ userMsgId: t.userMsgId, task: t.task })) ?? [];
+    return this.sessions.get(sessionId)?.queue.map((t) => ({ userMsgId: t.userMsgId, task: t.task, kind: t.kind })) ?? [];
+  }
+  /** The active turn's current todo/step checklist (ADR-255), for a (re)connecting client to show
+   *  up front. Empty when no turn has emitted one this turn (or the session is unknown). */
+  todos(sessionId) {
+    return this.sessions.get(sessionId)?.todos ?? [];
   }
   /** The in-flight turn's message ids, so a reconnecting stream can synthesize a `meta` frame
    *  even if the real one has already aged out of the ring buffer. */
@@ -16870,7 +17239,7 @@ var CodeRunManager = class {
     if (!s) {
       const emitter = new EventEmitter();
       emitter.setMaxListeners(0);
-      s = { convId, repoRoot, buffer: new RingBuffer(), emitter, queue: [], active: null, replayFloor: 0 };
+      s = { convId, repoRoot, buffer: new RingBuffer(), emitter, queue: [], active: null, replayFloor: 0, todos: [] };
       this.sessions.set(sessionId, s);
     }
     if (s.cleanupTimer) {
@@ -16889,11 +17258,36 @@ var CodeRunManager = class {
   enqueue(sessionId, params) {
     const s = this.ensure(sessionId, params.convId, params.repoRoot);
     const willQueue = s.active !== null;
-    s.queue.push({ task: params.task, userMsgId: params.userMsgId, thinkingBudget: params.thinkingBudget ?? -1 });
+    s.queue.push({ task: params.task, userMsgId: params.userMsgId, thinkingBudget: params.thinkingBudget ?? -1, kind: params.kind ?? "followUp" });
     this.emitQueue(sessionId);
     void this.pump(sessionId);
     return { queued: willQueue };
   }
+  /**
+   * Steer a message into the CURRENTLY ACTIVE turn (pi's session.steer, reached via the handle
+   * runCodeSession registers) so it redirects the running turn instead of queueing a fresh one
+   * behind it.
+   *
+   * Falls back to enqueue() (follow-up/queue) rather than erroring when there is nothing live to
+   * steer — either no active turn at all, or the active turn stopped streaming in the moment
+   * before we reached it (a race: the turn just finished). In the fallback the message is never
+   * dropped; it simply runs as the next turn instead, and its queue entry keeps kind:'steer' so
+   * the UI can still tell it apart from a plain follow-up.
+   *
+   * Returns `steered` (delivered into the live turn) and, when it wasn't, `queued` (whether the
+   * fallback had to wait behind an active turn, mirroring enqueue's own return).
+   */
+  async steer(sessionId, params) {
+    const active = this.sessions.get(sessionId)?.active;
+    if (active?.steer) {
+      try {
+        if (await active.steer(params.task)) return { steered: true, queued: false };
+      } catch {
+      }
+    }
+    const { queued } = this.enqueue(sessionId, { ...params, kind: "steer" });
+    return { steered: false, queued };
+  }
   /** The most recent real ctxUsed/ctxMax on record for this conversation (the last assistant
    *  turn that actually completed and got a genuine stats.ctxUsed from runCodeSession), or
    *  undefined if none exists yet. Used when a turn ABORTS before runCodeSession returns a
@@ -16937,8 +17331,9 @@ var CodeRunManager = class {
     this.emitQueue(sessionId);
     const assistantMsg = this.d.db.addMessage(s.convId, "assistant", "", { stats: { aborted: false } });
     const ac = new AbortController();
-    s.active = { ac, assistantMsgId: assistantMsg.id, userMsgId: turn.userMsgId };
+    s.active = { ac, assistantMsgId: assistantMsg.id, userMsgId: turn.userMsgId, steer: null };
     s.replayFloor = s.buffer.head();
+    s.todos = [];
     const push = (event, data) => {
       const ss = this.sessions.get(sessionId);
       if (!ss) return;
@@ -16960,7 +17355,10 @@ var CodeRunManager = class {
         if (last && last.type === "text") last.text += delta;
         else timeline.push({ type: "text", text: delta });
       } else if (ev.event === "reasoning") reasoning += String(data.delta ?? "");
-      else if (ev.event === "tool_call" && (data.status === "done" || data.status === "error")) {
+      else if (ev.event === "todos") {
+        const ss = this.sessions.get(sessionId);
+        if (ss) ss.todos = Array.isArray(data.todos) ? data.todos : [];
+      } else if (ev.event === "tool_call" && (data.status === "done" || data.status === "error")) {
         const id = String(data.id ?? "");
         toolCalls.push({
           id,
@@ -16992,7 +17390,14 @@ var CodeRunManager = class {
         thinkingBudget: turn.thinkingBudget,
         task: turn.task,
         signal: ac.signal,
-        sink
+        sink,
+        // Publish/withdraw the live turn's steer handle so steer() can inject into THIS turn.
+        // Reads s.active fresh each call (rather than closing over the ActiveTurn captured above)
+        // so a null clear can't accidentally resurrect a handle onto a since-replaced turn.
+        onSteerable: (steer) => {
+          const cur = this.sessions.get(sessionId)?.active;
+          if (cur && cur.ac === ac) cur.steer = steer;
+        }
       });
       const finalContent = content.trim() || result.finalText;
       if (!content.trim() && result.finalText.trim()) timeline.push({ type: "text", text: result.finalText });
@@ -17218,6 +17623,297 @@ function revertFileEdits(messages, repoRoot) {
   return { reverted, failed };
 }
 
+// src/code/session-export.ts
+var EXPORT_TRUNCATE_LIMIT = 2e4;
+function truncateForExport(text, limit = EXPORT_TRUNCATE_LIMIT) {
+  if (text.length <= limit) return text;
+  const cut = text.length - limit;
+  return `${text.slice(0, limit)}
+
+\u2026 [truncated \u2014 ${cut.toLocaleString()} more character${cut === 1 ? "" : "s"}] \u2026`;
+}
+function fence(lang, body6) {
+  return `\`\`\`${lang}
+${body6}
+\`\`\``;
+}
+function renderReasoning(reasoning) {
+  if (!reasoning.trim()) return "";
+  return `<details>
+<summary>Reasoning</summary>
+
+${reasoning.trim()}
+
+</details>
+
+`;
+}
+function renderToolCall(call) {
+  const parts = [`### Tool call: \`${call.name}\``];
+  const argsJson = (() => {
+    try {
+      return JSON.stringify(call.args, null, 2);
+    } catch {
+      return String(call.args);
+    }
+  })();
+  if (argsJson && argsJson !== "{}") parts.push(fence("json", truncateForExport(argsJson)));
+  if (call.diff) {
+    parts.push(fence("diff", truncateForExport(call.diff)));
+  } else if (call.error) {
+    parts.push(`**Error:**
+
+${fence("text", truncateForExport(call.error))}`);
+  } else if (call.result) {
+    parts.push(fence("text", truncateForExport(call.result)));
+  }
+  return parts.join("\n\n");
+}
+function legacyTimeline(message) {
+  const blocks = [];
+  if (message.content) blocks.push({ type: "text", text: message.content });
+  for (const call of message.toolCalls) blocks.push({ type: "tool", id: call.id });
+  return blocks;
+}
+function renderAssistantMessage(message) {
+  const toolsById = new Map(message.toolCalls.map((t) => [t.id, t]));
+  const timeline = message.timeline?.length ? message.timeline : legacyTimeline(message);
+  const parts = ["## Assistant"];
+  const reasoning = renderReasoning(message.reasoning);
+  if (reasoning) parts.push(reasoning.trimEnd());
+  for (const block of timeline) {
+    if (block.type === "text") {
+      if (block.text.trim()) parts.push(block.text.trim());
+    } else {
+      const call = toolsById.get(block.id);
+      if (call) parts.push(renderToolCall(call));
+    }
+  }
+  if (parts.length === 1) parts.push("*(no content)*");
+  return parts.join("\n\n");
+}
+function renderUserMessage(message) {
+  const parts = ["## You", message.content.trim() || "*(empty message)*"];
+  if (message.textAttachments.length) {
+    parts.push(`**Attached:** ${message.textAttachments.map((p) => `\`${p}\``).join(", ")}`);
+  }
+  return parts.join("\n\n");
+}
+function renderMessage(message) {
+  return message.role === "user" ? renderUserMessage(message) : renderAssistantMessage(message);
+}
+function serializeCodeSessionMarkdown(run, conv, opts = {}) {
+  const exportedAt = opts.exportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const title = run.title.trim() || "Untitled Code session";
+  const meta = [
+    `- **Session ID:** ${run.id}`,
+    run.repoRoot ? `- **Repo:** ${run.repoRoot}${run.repoBranch ? ` (branch: ${run.repoBranch})` : ""}` : void 0,
+    `- **Mode:** ${conv.agentMode ?? "auto"}`,
+    `- **Status:** ${run.status}`,
+    `- **Created:** ${run.createdAt}`,
+    `- **Exported:** ${exportedAt}`
+  ].filter((line) => !!line);
+  const messages = (conv.messages ?? []).slice().sort((a, b) => a.seq - b.seq);
+  const body6 = messages.length ? messages.map(renderMessage).join("\n\n---\n\n") : "*(no messages in this session yet)*";
+  return `# ${title}
+
+${meta.join("\n")}
+
+---
+
+${body6}
+`;
+}
+var MAX_FILENAME_SLUG = 80;
+function codeSessionExportFilename(title, createdAt, ext) {
+  const slug = title.replace(/[^a-zA-Z0-9 _-]/g, "").trim().replace(/\s+/g, "-").slice(0, MAX_FILENAME_SLUG).replace(/-+$/, "") || "code-session";
+  const dateStr = createdAt.slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return `${slug}-${dateStr}.${ext}`;
+}
+
+// src/code/git-actions.ts
+import { execFile as execFile12 } from "child_process";
+import { promisify as promisify9 } from "util";
+var execFileAsync = promisify9(execFile12);
+var GIT_TIMEOUT_MS = 15e3;
+var GIT_NETWORK_TIMEOUT_MS = 3e4;
+var GitError = class extends Error {
+  stderr;
+  exitCode;
+  constructor(message, stderr, exitCode) {
+    super(message);
+    this.name = "GitError";
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+  }
+};
+async function git(args, cwd, timeoutMs = GIT_TIMEOUT_MS) {
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      timeout: timeoutMs,
+      windowsHide: true,
+      // Never block on an interactive username/password/passphrase prompt — surface the auth
+      // failure as a normal command error instead of hanging the request.
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    });
+    return stdout.trim();
+  } catch (e) {
+    const failure = e;
+    if (failure.killed) throw new GitError(`git ${args[0]} timed out after ${timeoutMs}ms`, failure.stderr ?? "", null);
+    throw new GitError((failure.stderr ?? "").trim() || failure.message, failure.stderr ?? "", failure.code ?? null);
+  }
+}
+var EMPTY_STATUS = {
+  isRepo: false,
+  branch: "",
+  detached: false,
+  files: [],
+  hasRemote: false,
+  hasUpstream: false,
+  ahead: 0,
+  behind: 0
+};
+async function getGitStatus(repoRoot) {
+  try {
+    if (await git(["rev-parse", "--is-inside-work-tree"], repoRoot) !== "true") return EMPTY_STATUS;
+  } catch {
+    return EMPTY_STATUS;
+  }
+  let branch = "";
+  let detached = false;
+  try {
+    branch = await git(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
+    if (branch === "HEAD") {
+      detached = true;
+      branch = "";
+    }
+  } catch {
+  }
+  let hasRemote = false;
+  try {
+    hasRemote = (await git(["remote"], repoRoot)).length > 0;
+  } catch {
+  }
+  let hasUpstream = false;
+  let ahead = 0;
+  let behind = 0;
+  if (!detached && branch) {
+    try {
+      await git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], repoRoot);
+      hasUpstream = true;
+      const counts = await git(["rev-list", "--left-right", "--count", "HEAD...@{u}"], repoRoot);
+      const [a, b] = counts.split(/\s+/).map((n) => parseInt(n, 10) || 0);
+      ahead = a ?? 0;
+      behind = b ?? 0;
+    } catch {
+    }
+  }
+  const raw = await git(["status", "--porcelain=v1"], repoRoot);
+  const files = raw ? raw.split("\n").filter(Boolean).map((line) => ({ code: line.slice(0, 2), path: line.slice(3) })) : [];
+  return { isRepo: true, branch, detached, files, hasRemote, hasUpstream, ahead, behind };
+}
+async function commitGitChanges(repoRoot, message, files) {
+  const trimmedMessage = message.trim();
+  if (!trimmedMessage) throw new GitError("A commit message is required.", "", null);
+  const status = await getGitStatus(repoRoot);
+  if (!status.isRepo) throw new GitError("Not a git repository.", "", null);
+  if (status.files.length === 0) throw new GitError("Nothing to commit \u2014 the working tree is clean.", "", null);
+  if (files && files.length > 0) {
+    for (const f of files) {
+      if (!isContainedFromRoot(f, repoRoot)) throw new GitError(`Refusing to stage a path outside the repo: ${f}`, "", null);
+    }
+    await git(["add", "--", ...files], repoRoot);
+  } else {
+    await git(["add", "-A"], repoRoot);
+  }
+  const staged = await git(["diff", "--cached", "--name-only"], repoRoot).catch(() => "");
+  const stagedList = staged.split("\n").filter(Boolean);
+  if (stagedList.length === 0) throw new GitError("Nothing staged \u2014 the selected file(s) have no changes.", "", null);
+  await git(["commit", "-m", trimmedMessage], repoRoot);
+  const hash = await git(["rev-parse", "HEAD"], repoRoot);
+  return { hash, filesCommitted: stagedList.length };
+}
+async function pushGitBranch(repoRoot) {
+  const status = await getGitStatus(repoRoot);
+  if (!status.isRepo) return { ok: false, reason: "not_a_repo", message: "Not a git repository." };
+  if (status.detached) {
+    return { ok: false, reason: "detached_head", message: "Cannot push from a detached HEAD \u2014 check out a branch first." };
+  }
+  if (!status.hasRemote) return { ok: false, reason: "no_remote", message: "This repo has no configured remote." };
+  const args = status.hasUpstream ? ["push"] : ["push", "--set-upstream", "origin", status.branch];
+  try {
+    await git(args, repoRoot, GIT_NETWORK_TIMEOUT_MS);
+    return { ok: true, remote: "origin", branch: status.branch };
+  } catch (e) {
+    const ge = e;
+    if (/\[rejected\]|non-fast-forward|fetch first|tip of your current branch is behind/i.test(ge.stderr)) {
+      return {
+        ok: false,
+        reason: "diverged",
+        message: "The remote has commits this branch doesn't have. Pull/rebase first \u2014 never force-pushed automatically."
+      };
+    }
+    return { ok: false, reason: "push_failed", message: ge.message };
+  }
+}
+function buildGithubCompareUrl(remoteUrl, branch) {
+  const trimmed = remoteUrl.trim();
+  const httpsMatch = trimmed.match(/^https?:\/\/(?:[^@/]+@)?github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  const sshMatch = trimmed.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
+  const m = httpsMatch ?? sshMatch;
+  if (!m) return null;
+  const [, owner, repo] = m;
+  return `https://github.com/${owner}/${repo}/compare/${encodeURIComponent(branch)}?expand=1`;
+}
+async function getGithubCompareUrl(repoRoot, branch) {
+  let remoteUrl;
+  try {
+    remoteUrl = await git(["remote", "get-url", "origin"], repoRoot);
+  } catch {
+    return null;
+  }
+  return buildGithubCompareUrl(remoteUrl, branch);
+}
+
+// src/code/code-shell.ts
+var SHELL_MAX_OUTPUT = 1e5;
+var SHELL_TIMEOUT_SEC = 60;
+async function runShellCommand(command, repoRoot, sessionLabel, opts) {
+  const maxOutput = opts?.maxOutput ?? SHELL_MAX_OUTPUT;
+  const timeoutSec = opts?.timeoutSec ?? SHELL_TIMEOUT_SEC;
+  const ops = createRobustBashOperations({ sessionLabel });
+  let output = "";
+  let truncated = false;
+  const onData = (chunk) => {
+    if (truncated) return;
+    output += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    if (output.length > maxOutput) {
+      output = output.slice(0, maxOutput);
+      truncated = true;
+    }
+  };
+  const signal = opts?.signal ?? new AbortController().signal;
+  try {
+    const { exitCode } = await ops.exec(command, repoRoot, { onData, signal, timeout: timeoutSec, env: process.env });
+    return { command, output, exitCode, timedOut: false, truncated };
+  } catch (e) {
+    const msg2 = e instanceof Error ? e.message : String(e);
+    if (msg2.startsWith("timeout:")) return { command, output, exitCode: null, timedOut: true, truncated };
+    throw e;
+  }
+}
+function shellContextText(result) {
+  const body6 = result.output.trim() || "(no output)";
+  const status = result.timedOut ? ` (timed out after ${SHELL_TIMEOUT_SEC}s)` : result.exitCode !== null && result.exitCode !== 0 ? ` (exit code ${result.exitCode})` : "";
+  const trunc = result.truncated ? "\n\u2026(output truncated)" : "";
+  return `I ran a shell command in the repo${status}:
+
+$ ${result.command}
+
+${body6}${trunc}`;
+}
+
 // src/code/code-routes.ts
 function err5(c, s, code, msg2) {
   return c.json({ error: { code, message: msg2 } }, s);
@@ -17282,6 +17978,8 @@ function toSidebarRow(run) {
     del: run.linesRemoved ?? 0,
     mode: void 0,
     // filled from conv below when available
+    running: void 0,
+    // filled from CodeRunManager below when available
     createdAt: run.createdAt,
     repoRoot: run.repoRoot ?? "",
     error: run.error,
@@ -17327,16 +18025,17 @@ function registerCodeRoutes(app2, d) {
   });
   app2.get("/api/v1/code/sessions", (c) => {
     const filter = c.req.query("filter") ?? "active";
-    const runs2 = db2.listAgentRuns().filter((r) => {
+    const agentRuns = db2.listAgentRuns().filter((r) => {
       const conv = db2.getConversation(r.convId);
       if (conv?.kind !== "code") return false;
       if (filter === "active") return !r.archivedAt;
       if (filter === "archived") return !!r.archivedAt;
       return true;
     });
-    const rows = runs2.map((r) => {
+    const rows = agentRuns.map((r) => {
       const row = toSidebarRow(r);
       row.mode = db2.getConversation(r.convId)?.agentMode;
+      row.running = runs.isActive(r.id);
       return row;
     });
     return c.json({ sessions: rows });
@@ -17356,9 +18055,31 @@ function registerCodeRoutes(app2, d) {
       running: runs.isActive(run.id),
       // Tasks waiting behind the active turn — the server-side message queue, so its chips
       // survive a page reload / reconnect.
-      queued: runs.queued(run.id)
+      queued: runs.queued(run.id),
+      // The active turn's current step checklist (ADR-255), so a reopened session shows live
+      // progress immediately without waiting for the next update_todos frame. [] when none.
+      todos: runs.todos(run.id),
+      // Whether an AGENTS.md is actually loaded for this session (ADR-262's loaded-resources
+      // header) — project (<repoRoot>/AGENTS.md) and/or global (~/.turbollm/agents.md). Computed
+      // with the SAME lookup persona.ts injects into the prompt, so "shown as loaded" == "actually
+      // fed to the model". Both false when the session has no repoRoot.
+      hasAgentsMd: run.repoRoot ? agentsMdPresence(run.repoRoot, d.store.dir()) : { project: false, global: false }
     });
   });
+  app2.get("/api/v1/code/sessions/:id/export", (c) => {
+    const id = c.req.param("id");
+    const run = db2.getAgentRun(id);
+    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    const conv = db2.getConversation(run.convId, true);
+    if (!conv) return err5(c, 404, "not_found", "Session conversation not found.");
+    const format = c.req.query("format") === "html" ? "html" : "markdown";
+    if (format === "html") return err5(c, 400, "unsupported_format", "HTML export is not available yet \u2014 use format=markdown.");
+    const md = serializeCodeSessionMarkdown(run, conv);
+    const filename = codeSessionExportFilename(run.title, run.createdAt, "md");
+    c.header("Content-Disposition", `attachment; filename="${filename}"`);
+    c.header("Content-Type", "text/markdown; charset=utf-8");
+    return c.body(md);
+  });
   app2.patch("/api/v1/code/sessions/:id/mode", async (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
@@ -17434,6 +18155,7 @@ function registerCodeRoutes(app2, d) {
     const lastMsg = (conv?.messages ?? []).at(-1);
     if (!lastMsg) return err5(c, 400, "nothing_to_clear", "Nothing to clear yet.");
     if (run.clearedUpToMessageId === lastMsg.id) return err5(c, 400, "nothing_to_clear", "Already cleared up to the latest message.");
+    db2.deactivateMessagesUpTo(run.convId, lastMsg.id);
     db2.setClearedUpToMessageId(id, lastMsg.id);
     return c.json({ ok: true, clearedUpToMessageId: lastMsg.id });
   });
@@ -17448,6 +18170,7 @@ function registerCodeRoutes(app2, d) {
       return c.json({ ok: true });
     }
     if (!run.clearedUpToMessageId) return err5(c, 400, "not_cleared", "This session has not been cleared.");
+    db2.reactivateMessagesUpTo(run.convId, run.clearedUpToMessageId);
     db2.setClearedUpToMessageId(id, null);
     return c.json({ ok: true });
   });
@@ -17483,6 +18206,93 @@ function registerCodeRoutes(app2, d) {
     db2.setRevertedFromMessageId(id, messageId);
     return c.json({ ok: true, revertedFromMessageId: messageId, revertText: cut.revertText, revertedFiles, failedFiles });
   });
+  app2.get("/api/v1/code/sessions/:id/git/status", async (c) => {
+    const run = db2.getAgentRun(c.req.param("id"));
+    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
+    const status = await getGitStatus(run.repoRoot);
+    return c.json({ ok: true, status });
+  });
+  app2.post("/api/v1/code/sessions/:id/git/commit", async (c) => {
+    const id = c.req.param("id");
+    const run = db2.getAgentRun(id);
+    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
+    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before committing.");
+    const b = await body5(c);
+    try {
+      const result = await commitGitChanges(run.repoRoot, b.message ?? "", b.files);
+      return c.json({ ok: true, ...result });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "Commit failed.";
+      if (/commit message is required/i.test(message)) return err5(c, 400, "invalid_input", message);
+      if (/not a git repository/i.test(message)) return err5(c, 400, "not_a_git_repo", message);
+      if (/nothing to commit|nothing staged/i.test(message)) return err5(c, 400, "nothing_to_commit", message);
+      if (/outside the repo/i.test(message)) return err5(c, 400, "invalid_input", message);
+      return err5(c, 500, "git_commit_failed", message);
+    }
+  });
+  app2.post("/api/v1/code/sessions/:id/git/push", async (c) => {
+    const id = c.req.param("id");
+    const run = db2.getAgentRun(id);
+    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
+    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before pushing.");
+    const result = await pushGitBranch(run.repoRoot);
+    if (!result.ok) {
+      const status = result.reason === "diverged" ? 409 : 400;
+      return err5(c, status, result.reason, result.message);
+    }
+    const compareUrl = await getGithubCompareUrl(run.repoRoot, result.branch);
+    return c.json({ ok: true, remote: result.remote, branch: result.branch, compareUrl });
+  });
+  app2.get("/api/v1/code/sessions/:id/git/compare-url", async (c) => {
+    const run = db2.getAgentRun(c.req.param("id"));
+    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
+    const status = await getGitStatus(run.repoRoot);
+    if (!status.isRepo || status.detached || !status.branch) return c.json({ ok: true, compareUrl: null });
+    const compareUrl = await getGithubCompareUrl(run.repoRoot, status.branch);
+    return c.json({ ok: true, compareUrl });
+  });
+  app2.post("/api/v1/code/sessions/:id/exec", async (c) => {
+    const id = c.req.param("id");
+    const run = db2.getAgentRun(id);
+    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
+    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before running a command.");
+    const b = await body5(c);
+    const command = (b.command ?? "").trim();
+    if (!command) return err5(c, 400, "invalid_input", "A command is required.");
+    const feedToModel = b.feedToModel !== false;
+    let result;
+    try {
+      result = await runShellCommand(command, run.repoRoot, id);
+    } catch (e) {
+      return err5(c, 500, "exec_failed", e instanceof Error ? e.message : "Command failed to run.");
+    }
+    let messageId;
+    if (feedToModel) {
+      const msg2 = db2.addMessage(run.convId, "user", shellContextText(result), {
+        toolCalls: [{
+          id: `shell-${Date.now()}`,
+          name: "shell",
+          args: { command, exitCode: result.exitCode, timedOut: result.timedOut },
+          result: result.output
+        }]
+      });
+      messageId = msg2.id;
+    }
+    return c.json({
+      ok: true,
+      command,
+      output: result.output,
+      exitCode: result.exitCode,
+      timedOut: result.timedOut,
+      truncated: result.truncated,
+      messageId
+    }, 200);
+  });
   app2.post("/api/v1/code/sessions/:id/stop", (c) => {
     const id = c.req.param("id");
     runs.stop(id);
@@ -17497,6 +18307,7 @@ function registerCodeRoutes(app2, d) {
   app2.post("/api/v1/code/sessions/:id/messages", async (c) => {
     const id = c.req.param("id");
     const b = await body5(c);
+    const kind = b.kind === "steer" ? "steer" : "followUp";
     const run = db2.getAgentRun(id);
     if (!run) return err5(c, 404, "not_found", "Session not found.");
     const conv = db2.getConversation(run.convId, true);
@@ -17505,20 +18316,25 @@ function registerCodeRoutes(app2, d) {
     const ms = d.manager.status();
     if (ms.state !== "running" || !ms.model) return err5(c, 409, "model_not_loaded", "Load a model first.");
     if (!d.manager.target()) return err5(c, 409, "model_not_loaded", "Engine not running.");
-    const followUp = (b.content ?? "").trim();
+    const newContent = (b.content ?? "").trim();
     let userMsgId;
     let task;
-    if (followUp) {
-      userMsgId = db2.addMessage(run.convId, "user", followUp, { textAttachments: b.contextFiles }).id;
-      task = contextFilesBlock(b.contextFiles) + ((b.promptOverride ?? "").trim() || followUp);
+    if (newContent) {
+      userMsgId = db2.addMessage(run.convId, "user", newContent, { textAttachments: b.contextFiles }).id;
+      task = contextFilesBlock(b.contextFiles) + ((b.promptOverride ?? "").trim() || newContent);
     } else {
       const lastUser = (conv.messages ?? []).filter((m) => m.role === "user").at(-1);
       if (!lastUser) return err5(c, 400, "no_task", "No task to run.");
       userMsgId = lastUser.id;
       task = contextFilesBlock(lastUser.textAttachments) + lastUser.content;
     }
-    const { queued } = runs.enqueue(id, { convId: run.convId, repoRoot: run.repoRoot, task, userMsgId, thinkingBudget: b.thinkingBudget });
-    return c.json({ ok: true, queued, userMessageId: userMsgId }, 202);
+    const enqueueParams = { convId: run.convId, repoRoot: run.repoRoot, task, userMsgId, thinkingBudget: b.thinkingBudget };
+    if (kind === "steer") {
+      const { steered, queued: queued2 } = await runs.steer(id, enqueueParams);
+      return c.json({ ok: true, queued: queued2, steered, userMessageId: userMsgId }, 202);
+    }
+    const { queued } = runs.enqueue(id, enqueueParams);
+    return c.json({ ok: true, queued, steered: false, userMessageId: userMsgId }, 202);
   });
   app2.get("/api/v1/code/sessions/:id/stream", (c) => {
     const id = c.req.param("id");
@@ -17534,6 +18350,8 @@ function registerCodeRoutes(app2, d) {
       const meta = runs.activeMeta(id);
       if (meta) await stream.writeSSE({ event: "meta", data: JSON.stringify(meta) });
       await stream.writeSSE({ event: "queue", data: JSON.stringify({ queued: runs.queued(id) }) });
+      const currentTodos = runs.todos(id);
+      if (currentTodos.length > 0) await stream.writeSSE({ event: "todos", data: JSON.stringify({ todos: currentTodos }) });
       for await (const ev of sub) {
         await stream.writeSSE({ id: String(ev.seq), event: ev.event, data: JSON.stringify(ev.data) });
       }
@@ -18219,7 +19037,7 @@ function contentType(file) {
 }
 
 // src/tunnel/manager.ts
-import { execFile as execFile12, spawn as spawn7, spawnSync as spawnSync2 } from "child_process";
+import { execFile as execFile13, spawn as spawn7, spawnSync as spawnSync2 } from "child_process";
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync14, readdirSync as readdirSync9, rmSync as rmSync14, writeFileSync as writeFileSync13 } from "fs";
 import { join as join31 } from "path";
 
@@ -18299,13 +19117,13 @@ function sleep4(ms) {
 }
 function signalTerm2(child) {
   if (!child.pid) return;
-  if (process.platform === "win32") execFile12("taskkill", ["/PID", String(child.pid), "/T"], () => {
+  if (process.platform === "win32") execFile13("taskkill", ["/PID", String(child.pid), "/T"], () => {
   });
   else child.kill("SIGTERM");
 }
 function forceKill2(child) {
   if (!child.pid) return;
-  if (process.platform === "win32") execFile12("taskkill", ["/PID", String(child.pid), "/F", "/T"], () => {
+  if (process.platform === "win32") execFile13("taskkill", ["/PID", String(child.pid), "/F", "/T"], () => {
   });
   else child.kill("SIGKILL");
 }