@todos-dev/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -119,19 +119,23 @@ async function withRetry(fn, shouldRetry, label, delays = DEFAULT_RETRY_DELAYS_M
 function workspacesRoot() {
   return process.env.TDS_WORKSPACES_DIR ?? (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".tds", "workspaces");
 }
-function spawnGit(args2, cwd) {
+function gitEnv(config2) {
+  const entries = Object.entries({ "credential.helper": "", ...config2 });
+  const env = { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_CONFIG_COUNT: String(entries.length) };
+  entries.forEach(([key, value], i) => {
+    env[`GIT_CONFIG_KEY_${i}`] = key;
+    env[`GIT_CONFIG_VALUE_${i}`] = value;
+  });
+  return env;
+}
+function authConfig(token) {
+  return { [`url.https://x-access-token:${token}@github.com/.insteadOf`]: "https://github.com/" };
+}
+function spawnGit(args2, cwd, config2 = {}) {
   return new Promise((resolve, reject) => {
     const child = (0, import_node_child_process.spawn)("git", args2, {
       cwd,
-      env: {
-        ...process.env,
-        GIT_TERMINAL_PROMPT: "0",
-        // Override any system credential helper (e.g. gh auth git-credential) so
-        // git uses the token embedded in the URL directly and never calls an external helper.
-        GIT_CONFIG_COUNT: "1",
-        GIT_CONFIG_KEY_0: "credential.helper",
-        GIT_CONFIG_VALUE_0: ""
-      },
+      env: gitEnv(config2),
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -154,9 +158,9 @@ function isTransientGitError(err) {
   const msg = err instanceof Error ? err.message : String(err);
   return /SSL_ERROR_SYSCALL|SSL_connect|gnutls_handshake|[Cc]ould not resolve host|Temporary failure in name resolution|Connection (timed out|reset|refused)|Operation timed out|Failed to connect|[Rr]ecv failure|[Ss]end failure|early EOF|RPC failed|unexpected disconnect|remote end hung up|The requested URL returned error: 5\d\d/.test(msg);
 }
-function runGit(args2, cwd) {
-  if (!RETRYABLE_GIT_OPS.has(args2[0])) return spawnGit(args2, cwd);
-  return withRetry(() => spawnGit(args2, cwd), isTransientGitError, `[workspace] git ${args2[0]}`);
+function runGit(args2, cwd, config2) {
+  if (!RETRYABLE_GIT_OPS.has(args2[0])) return spawnGit(args2, cwd, config2);
+  return withRetry(() => spawnGit(args2, cwd, config2), isTransientGitError, `[workspace] git ${args2[0]}`);
 }
 async function pruneIgnoredFromIndex(cwd) {
   try {
@@ -172,31 +176,18 @@ async function pruneIgnoredFromIndex(cwd) {
 function redactToken(text3) {
   return text3.replace(/x-access-token:[^@]+@/g, "x-access-token:***@");
 }
-function authUrl(repoFullName, token) {
-  return `https://x-access-token:${token}@github.com/${repoFullName}.git`;
-}
 function cleanUrl(repoFullName) {
   return `https://github.com/${repoFullName}.git`;
 }
-async function pushBranch(cwd, repoFullName, token, branch) {
-  await runGit(["remote", "set-url", "origin", authUrl(repoFullName, token)], cwd);
-  try {
-    await runGit(["push", "--force-with-lease", "-u", "origin", branch], cwd);
-  } finally {
-    await runGit(["remote", "set-url", "origin", cleanUrl(repoFullName)], cwd).catch(() => {
-    });
-  }
+async function pushBranch(cwd, token, branch) {
+  await runGit(["push", "--force-with-lease", "-u", "origin", branch], cwd, authConfig(token));
 }
-async function fetchRef(baseDir, repoFullName, token, ref) {
-  await runGit(["remote", "set-url", "origin", authUrl(repoFullName, token)], baseDir);
+async function fetchRef(baseDir, token, ref) {
   try {
-    await runGit(["fetch", "origin", ref], baseDir);
+    await runGit(["fetch", "origin", ref], baseDir, authConfig(token));
     return true;
   } catch {
     return false;
-  } finally {
-    await runGit(["remote", "set-url", "origin", cleanUrl(repoFullName)], baseDir).catch(() => {
-    });
   }
 }
 var projectLocks = /* @__PURE__ */ new Map();
@@ -214,22 +205,15 @@ async function ensureBaseRepo(baseDir, repoFullName, defaultBranch, token) {
       () => {
         (0, import_node_fs2.rmSync)(baseDir, { recursive: true, force: true });
         (0, import_node_fs2.mkdirSync)(baseDir, { recursive: true });
-        return spawnGit(["clone", "--branch", defaultBranch, authUrl(repoFullName, token), baseDir]);
+        return spawnGit(["clone", "--branch", defaultBranch, cleanUrl(repoFullName), baseDir], void 0, authConfig(token));
       },
       isTransientGitError,
       "[workspace] git clone"
     );
-    await runGit(["remote", "set-url", "origin", cleanUrl(repoFullName)], baseDir);
     return;
   }
   console.log(`[workspace] Fetching ${repoFullName} (branch: ${defaultBranch})\u2026`);
-  await runGit(["remote", "set-url", "origin", authUrl(repoFullName, token)], baseDir);
-  try {
-    await runGit(["fetch", "origin", defaultBranch], baseDir);
-  } finally {
-    await runGit(["remote", "set-url", "origin", cleanUrl(repoFullName)], baseDir).catch(() => {
-    });
-  }
+  await runGit(["fetch", "origin", defaultBranch], baseDir, authConfig(token));
 }
 async function prepareConversationWorkspace(projectId, conversationId, repoFullName, defaultBranch, token, opts = {}) {
   return withProjectLock(projectId, async () => {
@@ -242,7 +226,7 @@ async function prepareConversationWorkspace(projectId, conversationId, repoFullN
     const worktreeExists = (0, import_node_fs2.existsSync)((0, import_node_path2.join)(worktreeDir, ".git"));
     let convBranchFetched = false;
     if (restoringToCommit || !worktreeExists) {
-      convBranchFetched = await fetchRef(baseDir, repoFullName, token, branchName);
+      convBranchFetched = await fetchRef(baseDir, token, branchName);
     }
     const assertReachable = async (cwd) => {
       if (!restoringToCommit) return;
@@ -377,12 +361,17 @@ var MAX_TIMEOUT_MS = 12e4;
 var IDLE_MS = 800;
 var OUTPUT_CAP = 6e4;
 var NO_RUNNER_MSG = "No exec-enabled runner is connected for this build. Add a sync machine for this todo (with command execution enabled) in the web app, and make sure it is online (`tds start`) with Runner enabled. Until then commands cannot run on a runner.";
-function makeClientShellTool(tunnel, build, runners = []) {
-  const runnerList = runners.length ? `Available runner machines: ${runners.map((r) => r.name).join(", ")}.` : "No exec-enabled runner machines are currently attached to this todo.";
+var RECONNECT_NOTE = "[shell reconnected \u2014 the previous shell session was lost: cwd, env vars and background processes were reset]";
+function disconnectedMsg(runner) {
+  const cause = runner.online === false ? "its machine is offline (no presence heartbeat \u2014 `tds start` may have stopped, or the machine is asleep/disconnected)" : "the sync shell channel to it is down (the sync client may be reconnecting)";
+  return `Runner "${runner.name}" is attached, but ${cause}. Wait a moment and retry; if this persists, ask the user to check the runner machine.`;
+}
+function makeClientShellTool(tunnel, build, runnersRef) {
+  const runnerList = runnersRef.current.length ? `Available runner machines: ${runnersRef.current.map((r) => r.name).join(", ")}.` : "No exec-enabled runner machines are currently attached to this todo (the set can change mid-conversation).";
   return {
     name: "client_shell",
     label: "Client Shell",
-    description: "Run a command in a persistent interactive shell on a RUNNER MACHINE \u2014 a separate host the build's worktree is mirrored onto. Use this (not bash) to run tests, start dev servers, or configure an environment that only exists on the runner. The shell is stateful: cwd, environment variables, and background processes persist across calls. Send a command with `input`; call again with empty input to read more output from a long-running command; set `interrupt` to send Ctrl-C. When several runners are attached, pass `machine` to pick one. " + runnerList,
+    description: "Run a command in a persistent interactive shell on a RUNNER MACHINE \u2014 a separate host the build's worktree is mirrored onto. Use this (not bash) to run tests, start dev servers, or configure an environment that only exists on the runner. The shell is stateful: cwd, environment variables, and background processes persist across calls \u2014 but only while the runner's sync connection holds. If sync drops, the shell (and anything running in it) dies; a reconnect opens a fresh shell and the next result says so. Send a command with `input`; call again with empty input to read more output from a long-running command; set `interrupt` to send Ctrl-C. When several runners are attached, pass `machine` to pick one. " + runnerList,
     parameters: {
       type: "object",
       properties: {
@@ -400,11 +389,19 @@ function makeClientShellTool(tunnel, build, runners = []) {
       if (!tunnel || !tunnel.shellAvailable()) {
         return text("Reverse shell is unavailable: the sync tunnel sidecar is not running on this machine.", { closed: true, truncated: false });
       }
-      const picked = resolveMachine(runners, p.machine);
+      const picked = resolveMachine(runnersRef.current, p.machine);
       if ("error" in picked) return text(picked.error, { closed: true, truncated: false });
-      const machineId = picked.machineId;
+      const runner = picked.runner;
+      const machineId = runner.machineId;
       const t = tunnel;
       const payload = shellPayload(p);
+      if (t.shellConnected(build, machineId) === false) {
+        const out = t.drainShell(build, machineId);
+        const msg = disconnectedMsg(runner);
+        return text(out.trim() ? `${out}
+[shell disconnected]
+${msg}` : msg, { closed: true, truncated: false });
+      }
       return new Promise((resolve) => {
         let settled = false;
         let closed = false;
@@ -419,7 +416,7 @@ function makeClientShellTool(tunnel, build, runners = []) {
           clearTimeout(maxTimer);
           signal?.removeEventListener("abort", onAbort);
           unsub();
-          resolve(res ?? shellResult(t.drainShell(build, machineId), closed));
+          resolve(res ?? shellResult(t, build, runner, closed));
         };
         const onAbort = () => finish();
         const armIdle = () => {
@@ -439,11 +436,6 @@ function makeClientShellTool(tunnel, build, runners = []) {
           finish();
           return;
         }
-        if (payload === "" && t.shellClosed(build, machineId)) {
-          closed = true;
-          finish();
-          return;
-        }
         if (payload !== "" && !t.shellSendInput(build, machineId, payload)) {
           finish(text("Reverse shell is unavailable: failed to write to the sidecar.", { closed: true, truncated: false }));
         } else {
@@ -459,9 +451,9 @@ function resolveMachine(runners, requested) {
     const q = requested.trim().toLowerCase();
     const hit = runners.find((r) => r.machineId.toLowerCase() === q || r.name.toLowerCase() === q);
     if (!hit) return { error: `Unknown runner "${requested}". Available: ${runners.map((r) => r.name).join(", ")}.` };
-    return { machineId: hit.machineId };
+    return { runner: hit };
   }
-  if (runners.length === 1) return { machineId: runners[0].machineId };
+  if (runners.length === 1) return { runner: runners[0] };
   return { error: `Several runners are attached \u2014 pass "machine" to pick one: ${runners.map((r) => r.name).join(", ")}.` };
 }
 function shellPayload(p) {
@@ -470,11 +462,20 @@ function shellPayload(p) {
 function clampTimeout(ms) {
   return Math.min(Math.max(Number(ms) || DEFAULT_TIMEOUT_MS, 1e3), MAX_TIMEOUT_MS);
 }
-function shellResult(out, closed) {
+function shellResult(t, build, runner, closed) {
+  const reconnected = t.consumeShellReconnect(build, runner.machineId);
+  let out = t.drainShell(build, runner.machineId);
   const truncated = out.length > OUTPUT_CAP;
   if (truncated) out = out.slice(-OUTPUT_CAP);
-  if (closed && out.trim() === "") return text(NO_RUNNER_MSG, { closed: true, truncated: false });
-  return text((out || "(no output)") + (closed ? "\n[shell session closed]" : ""), { closed, truncated });
+  if (closed && out.trim() === "" && !reconnected) {
+    return text(disconnectedMsg(runner), { closed: true, truncated: false });
+  }
+  const parts = [];
+  if (reconnected) parts.push(RECONNECT_NOTE);
+  if (truncated) parts.push(`[output truncated to the last ${OUTPUT_CAP} characters]`);
+  parts.push(out || "(no output)");
+  if (closed) parts.push("[shell session closed]");
+  return text(parts.join("\n"), { closed, truncated });
 }
 function text(s, details) {
   return { content: [{ type: "text", text: s }], details };
@@ -514,19 +515,28 @@ function makeListTodosTool(serverUrl, token, step) {
   return {
     name: "list_todos",
     label: "List Todos",
-    description: 'List the todos in this project so you can see existing/related work and find a todo to update. Returns each todo as "#<seq> [<phase>] <title> (id: <id>)"; todos you created are marked (yours).',
+    description: `List the todos in this project so you can see existing/related work and find a todo to update. The first line lists the project's tags with their ids (usable as update_todo's tagIds). Returns each todo as "#<seq> [<phase>] <title> (id: <id>) [tags: \u2026]"; todos you created are marked (yours).`,
     parameters: { type: "object", properties: {}, required: [], additionalProperties: false },
     async execute() {
       if (!projectId) return text2("No project context for this turn \u2014 todos are unavailable.");
-      const reply = await request(serverUrl, "GET", `/api/projects/${projectId}/todos`, token);
+      const [reply, tagsReply] = await Promise.all([
+        request(serverUrl, "GET", `/api/projects/${projectId}/todos`, token),
+        request(serverUrl, "GET", `/api/projects/${projectId}/tags`, token)
+      ]);
       if (!reply.ok) return text2(errorText(reply, "Failed to list todos"));
       const todos = reply.body ?? [];
       if (!todos.length) return text2("No todos in this project yet.");
+      const tags = tagsReply.ok ? tagsReply.body ?? [] : [];
+      const tagName = new Map(tags.map((t) => [t.id, t.name]));
+      const header = tags.length ? `Project tags: ${tags.map((t) => `${t.name} (id: ${t.id})`).join(", ")}
+` : "";
       const lines = todos.map((t) => {
         const mine = t.createdBy === step.agent.agentId ? " (yours)" : "";
-        return `#${t.seqNum} [${t.phase}] ${t.title} (id: ${t.id})${mine}`;
+        const names = (t.tagIds ?? []).map((id) => tagName.get(id)).filter(Boolean);
+        const tagsStr = names.length ? ` [tags: ${names.join(", ")}]` : "";
+        return `#${t.seqNum} [${t.phase}] ${t.title} (id: ${t.id})${tagsStr}${mine}`;
       });
-      let out = lines.join("\n");
+      let out = header + lines.join("\n");
       if (out.length > LIST_CAP) out = out.slice(0, LIST_CAP) + "\n\u2026(truncated)";
       return text2(out);
     }
@@ -566,14 +576,14 @@ function makeUpdateTodoTool(serverUrl, token, step) {
   return {
     name: "update_todo",
     label: "Update Todo",
-    description: `Update a todo YOU created (only your own \u2014 found via list_todos, marked "(yours)"). You can change its title, spec, or tags. Use this to refine a follow-up todo as you learn more. You cannot edit todos created by others or the user, change a todo's phase, or start a build.`,
+    description: `Update a todo YOU created (only your own \u2014 found via list_todos, marked "(yours)"). You can change its title, spec, or tags (tag ids come from the "Project tags" line of list_todos). Use this to refine a follow-up todo as you learn more. You cannot edit todos created by others or the user, change a todo's phase, or start a build.`,
     parameters: {
       type: "object",
       properties: {
         id: { type: "string", description: "The id of the todo to update (from list_todos)." },
         title: { type: "string", description: "New title (optional)." },
         spec: { type: "string", description: "New spec/description (optional)." },
-        tagIds: { type: "array", items: { type: "string" }, description: "Replacement tag id list (optional)." }
+        tagIds: { type: "array", items: { type: "string" }, description: `Replacement tag id list; ids come from list_todos's "Project tags" line (optional).` }
       },
       required: ["id"],
       additionalProperties: false
@@ -689,14 +699,12 @@ async function materializeSession(opts) {
     return {
       sessionManager: opts.sdk.SessionManager.open(mode.sessionFilePath, sessionsDir(), opts.cwd),
       isContinue: true,
-      sessionFilePath: mode.sessionFilePath,
       sessionKeyForSave: null
     };
   }
   return {
-    sessionManager: opts.sdk.SessionManager.create(opts.cwd, sessionsDir(), { id: opts.createSessionId }),
+    sessionManager: opts.sdk.SessionManager.create(opts.cwd, sessionsDir(), { id: opts.sessionKey }),
     isContinue: false,
-    sessionFilePath: null,
     sessionKeyForSave: opts.sessionKey
   };
 }
@@ -866,7 +874,6 @@ function ensureSkillGc(agentDir) {
 }
 
 // src/lib/streaming.ts
-var LOCAL_EXECUTED_TOOLS = /* @__PURE__ */ new Set(["read", "write", "edit", "bash", "grep", "find", "ls", "web_fetch", "client_shell", "list_todos", "create_todo", "update_todo"]);
 function formatToolInput(toolName, args2) {
   if (!args2) return "";
   switch (toolName) {
@@ -891,22 +898,32 @@ function formatToolInput(toolName, args2) {
     }
   }
 }
+async function postRaw(serverUrl, path, body, token) {
+  const headers = { "Content-Type": "application/json" };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  const res = await fetch(`${serverUrl}${path}`, { method: "POST", headers, body: JSON.stringify(body) });
+  if (!res.ok) throw Object.assign(new Error(`HTTP ${res.status}`), { httpStatus: res.status });
+  return await res.json();
+}
 async function post(serverUrl, path, body, token) {
   try {
-    const headers = { "Content-Type": "application/json" };
-    if (token) headers["Authorization"] = `Bearer ${token}`;
-    const res = await fetch(`${serverUrl}${path}`, { method: "POST", headers, body: JSON.stringify(body) });
-    if (!res.ok) {
-      console.error(`[machine] POST ${path} \u2192 HTTP ${res.status}`);
-      return {};
-    }
-    return await res.json();
+    return await postRaw(serverUrl, path, body, token);
   } catch (err) {
     console.error(`[machine] POST ${path} failed:`, err.message);
     return {};
   }
 }
-function startHeartbeat(serverUrl, stepId, agentId, onSignal, token) {
+async function postCritical(serverUrl, path, body, token) {
+  return withRetry(
+    () => postRaw(serverUrl, path, body, token),
+    (err) => {
+      const status = err.httpStatus;
+      return status === void 0 || status >= 500;
+    },
+    `[machine] POST ${path}`
+  );
+}
+function startHeartbeat(serverUrl, stepId, agentId, onSignal, token, onRunners) {
   let active = true;
   let inFlight = false;
   const tick = async () => {
@@ -915,6 +932,7 @@ function startHeartbeat(serverUrl, stepId, agentId, onSignal, token) {
     try {
       const res = await post(serverUrl, `/api/machine/heartbeat/${stepId}`, { agentId }, token);
       if (active && res.stop) onSignal();
+      if (active && Array.isArray(res.runners)) onRunners?.(res.runners);
     } finally {
       inFlight = false;
     }
@@ -926,7 +944,14 @@ function startHeartbeat(serverUrl, stepId, agentId, onSignal, token) {
     clearInterval(id);
   };
 }
-function attachStreamingSession(session, label, postToken) {
+var POST_PACING_MS = 50;
+function mergeKind(body) {
+  if (typeof body.text !== "string") return null;
+  if (body.type === void 0) return "text";
+  if (body.type === "thinking") return "thinking";
+  return null;
+}
+function attachStreamingSession(session, label, postToken, onStop) {
   const abort = new AbortController();
   abort.signal.addEventListener("abort", () => {
     try {
@@ -934,43 +959,37 @@ function attachStreamingSession(session, label, postToken) {
     } catch {
     }
   });
-  let textBuffer = "";
-  let thinkingBuffer = "";
   let fullText = "";
-  let assistantStarted = false;
   let lastModelError;
-  const startAssistant = () => {
-    assistantStarted = true;
-    textBuffer = "";
-    thinkingBuffer = "";
-  };
-  const ensureAssistant = () => {
-    if (!assistantStarted) startAssistant();
-  };
-  const emitToolStart = (toolName, detail) => {
-    ensureAssistant();
-    postToken({ type: "tool_start", toolName, detail });
+  const queue = [];
+  let pump = Promise.resolve();
+  let pumping = false;
+  const runPump = async () => {
+    try {
+      while (queue.length) {
+        const res = await postToken(queue.shift());
+        if (res.stop) onStop();
+        if (queue.length) await new Promise((r) => setTimeout(r, POST_PACING_MS));
+      }
+    } finally {
+      pumping = false;
+    }
   };
-  const flush = () => {
-    if (textBuffer) {
-      const c = textBuffer;
-      textBuffer = "";
-      postToken({ text: c });
+  const push = (body) => {
+    const kind = mergeKind(body);
+    const last = queue[queue.length - 1];
+    if (kind && last && mergeKind(last) === kind) {
+      last.text = last.text + body.text;
+      return;
     }
-    if (thinkingBuffer) {
-      const c = thinkingBuffer;
-      thinkingBuffer = "";
-      postToken({ type: "thinking", text: c });
+    queue.push(body);
+    if (!pumping) {
+      pumping = true;
+      pump = runPump();
     }
   };
-  const flushTimer = setInterval(flush, 50);
   const unsub = session.subscribe((event) => {
     const ev = event;
-    if (ev.type === "message_start") {
-      const message = ev.message;
-      if (message?.role === "assistant") startAssistant();
-      return;
-    }
     if (ev.type === "message_end") {
       const message = ev.message;
       const stopReason = message?.stopReason;
@@ -989,33 +1008,23 @@ function attachStreamingSession(session, label, postToken) {
       if (!ev.success) console.error(`[${label}] auto_retry_end failed finalError=${ev.finalError}`);
       return;
     }
-    if (ev.type === "tool_execution_start") {
-      const toolName = String(ev.toolName ?? "tool");
-      const args2 = ev.args;
-      emitToolStart(toolName, formatToolInput(toolName, args2));
-      return;
-    }
     if (ev.type === "message_update") {
       const ame = ev.assistantMessageEvent;
       if (ame?.type === "text_delta") {
         const delta = String(ame.delta ?? "");
         if (delta) {
-          ensureAssistant();
-          textBuffer += delta;
           fullText += delta;
+          push({ text: delta });
         }
       } else if (ame?.type === "thinking_delta") {
         const delta = String(ame.delta ?? "");
-        if (delta) {
-          ensureAssistant();
-          thinkingBuffer += delta;
-        }
+        if (delta) push({ type: "thinking", text: delta });
       } else if (ame?.type === "toolcall_end") {
         const toolCall = ame.toolCall;
         const toolName = String(toolCall?.name ?? "");
-        if (toolName && !LOCAL_EXECUTED_TOOLS.has(toolName)) {
+        if (toolName) {
           const args2 = toolCall?.arguments;
-          emitToolStart(toolName, formatToolInput(toolName, args2));
+          push({ type: "tool_start", toolName, detail: formatToolInput(toolName, args2) });
         }
       }
     }
@@ -1024,7 +1033,6 @@ function attachStreamingSession(session, label, postToken) {
   const dispose = () => {
     if (disposed) return;
     disposed = true;
-    clearInterval(flushTimer);
     unsub();
     try {
       session.dispose();
@@ -1033,16 +1041,17 @@ function attachStreamingSession(session, label, postToken) {
   };
   return {
     abort,
-    flush,
     getFullText: () => fullText,
     getLastModelError: () => lastModelError,
+    idle: () => pump,
     dispose
   };
 }
 
 // src/machine.ts
-function makeDone(serverUrl, stepId, agentId, conversationId, token) {
-  return (payload) => post(serverUrl, `/api/machine/done/${stepId}`, { agentId, conversationId, ...payload }, token);
+function makeDone(step, serverUrl, token) {
+  const { stepId, conversationId, mode, agent: { agentId } } = step;
+  return (payload) => postCritical(serverUrl, `/api/machine/done/${stepId}`, { agentId, conversationId, mode, ...payload }, token).catch((err) => console.error(`[step] ${stepId} done report failed:`, err.message));
 }
 async function computeDiffHash(cwd, defaultBranch, stepId) {
   try {
@@ -1105,7 +1114,7 @@ async function prepareStepWorkspace(step) {
     workspace.repoFullName,
     workspace.defaultBranch,
     workspace.installationToken,
-    // Lazy/pure rewind: land the worktree on the checkpoint before any prompt or mirror reads it.
+    // Pure restore step: land the worktree on the checkpoint before the mirror/PR reads it.
     step.restore ? { restoreTo: step.restore.commitSha ?? `origin/${workspace.defaultBranch}` } : {}
   );
 }
@@ -1166,18 +1175,22 @@ async function executeStep(step, serverUrl, token, tunnel) {
   console.log(`[step] ${stepId} start (conv ${conversationId})`);
   let interrupted = false;
   let abortRef = null;
-  const stopHeartbeat = startHeartbeat(serverUrl, stepId, agentId, () => {
+  const stopTurn = () => {
     interrupted = true;
     abortRef?.abort();
-  }, token);
-  const done2 = makeDone(serverUrl, stepId, agentId, conversationId, token);
+  };
+  const runnersRef = { current: step.runners ?? [] };
+  const stopHeartbeat = startHeartbeat(serverUrl, stepId, agentId, stopTurn, token, (r) => {
+    runnersRef.current = r;
+  });
+  const done = makeDone(step, serverUrl, token);
   try {
     const runtime = await getPiRuntime();
     const { sdk, authStorage, modelRegistry, agentDir } = runtime;
     ensureSkillGc(agentDir);
     const model = resolveModel(modelRegistry, step.agent);
     if (!model) {
-      await done2({ error: "No authenticated model available on this machine. Run `tds provider add` (or `tds provider login <name>`) on the machine." });
+      await done({ error: "No authenticated model available on this machine. Run `tds provider add` (or `tds provider login <name>`) on the machine." });
       return;
     }
     console.log(`[step] ${stepId} using model ${model.provider}/${model.id}`);
@@ -1185,29 +1198,20 @@ async function executeStep(step, serverUrl, token, tunnel) {
     try {
       cwd = await prepareStepWorkspace(step) ?? agentDir;
     } catch (err) {
-      await done2({ error: `Workspace preparation failed: ${err.message}` });
+      await done({ error: `Workspace preparation failed: ${err.message}` });
       return;
     }
-    if (step.restore) {
-      try {
-        await restoreSessionToCheckpoint(step);
-      } catch (err) {
-        await done2({ error: `Session rewind failed: ${err.message}` });
-        return;
-      }
-    }
     const ephemeral = step.mode === "ephemeral_turn";
-    const m = ephemeral ? { sessionManager: sdk.SessionManager.inMemory(cwd), isContinue: false, sessionFilePath: null, sessionKeyForSave: null } : await materializeSession({
+    const m = ephemeral ? { sessionManager: sdk.SessionManager.inMemory(cwd), isContinue: false, sessionKeyForSave: null } : await materializeSession({
       sdk,
       sessionKey: conversationId,
       cwd,
-      createSessionId: conversationId,
       restoreUrl: step.sessionRestoreUrl
     });
     console.log(m.isContinue ? `[step] ${stepId} continue session ${conversationId}` : `[step] ${stepId} new session ${conversationId}`);
     const skills = await materializeSkills(step.skills, agentDir);
     const extraCustomTools = [
-      makeClientShellTool(tunnel, conversationId, step.runners),
+      makeClientShellTool(tunnel, conversationId, runnersRef),
       ...makeTodoTools(serverUrl, token, step)
     ];
     const session = await createSession(sdk, {
@@ -1226,62 +1230,14 @@ async function executeStep(step, serverUrl, token, tunnel) {
     if (m.sessionKeyForSave && session.sessionFile) {
       saveSessionPath(m.sessionKeyForSave, session.sessionFile);
     }
-    let flushChain = Promise.resolve();
-    let mergeableTextTail = null;
-    let mergeableThinkingTail = null;
-    const enqueueTokenPost = (body) => {
-      const isPlainText = typeof body.text === "string" && body.type === void 0;
-      const isThinking = body.type === "thinking" && typeof body.text === "string";
-      if (isPlainText) {
-        mergeableThinkingTail = null;
-        if (mergeableTextTail) {
-          mergeableTextTail.text += body.text;
-          return;
-        }
-        const tail = { text: body.text };
-        mergeableTextTail = tail;
-        flushChain = flushChain.then(async () => {
-          mergeableTextTail = null;
-          const res = await post(serverUrl, `/api/machine/token/${stepId}`, { agentId, text: tail.text }, token);
-          if (res.stop && !interrupted) {
-            interrupted = true;
-            abortRef?.abort();
-          }
-        });
-        return;
-      }
-      if (isThinking) {
-        mergeableTextTail = null;
-        if (mergeableThinkingTail) {
-          mergeableThinkingTail.text += body.text;
-          return;
-        }
-        const tail = { text: body.text };
-        mergeableThinkingTail = tail;
-        flushChain = flushChain.then(async () => {
-          mergeableThinkingTail = null;
-          const res = await post(serverUrl, `/api/machine/token/${stepId}`, { agentId, type: "thinking", text: tail.text }, token);
-          if (res.stop && !interrupted) {
-            interrupted = true;
-            abortRef?.abort();
-          }
-        });
-        return;
-      }
-      mergeableTextTail = null;
-      mergeableThinkingTail = null;
-      flushChain = flushChain.then(async () => {
-        const res = await post(serverUrl, `/api/machine/token/${stepId}`, { agentId, ...body }, token);
-        if (res.stop && !interrupted) {
-          interrupted = true;
-          abortRef?.abort();
-        }
-      });
-    };
-    const stream = attachStreamingSession(session, `step:${stepId}`, enqueueTokenPost);
+    const stream = attachStreamingSession(
+      session,
+      `step:${stepId}`,
+      (body) => post(serverUrl, `/api/machine/token/${stepId}`, { agentId, ...body }, token),
+      stopTurn
+    );
     abortRef = stream.abort;
     if (interrupted) stream.abort.abort();
-    const fullPrompt = step.prompt;
     let commitSha;
     let sessionLeafEntryId;
     let diffHash;
@@ -1297,10 +1253,10 @@ async function executeStep(step, serverUrl, token, tunnel) {
       } catch (err) {
         console.warn(`[step] ${stepId} checkpoint commit failed:`, err.message);
       }
-      const { repoFullName, installationToken, defaultBranch } = step.workspace;
+      const { installationToken, defaultBranch } = step.workspace;
       const branchName = `tds/conv-${conversationId}`;
       try {
-        await pushBranch(cwd, repoFullName, installationToken, branchName);
+        await pushBranch(cwd, installationToken, branchName);
         console.log(`[step] ${stepId} pushed ${branchName}`);
       } catch (err) {
         console.error(`[step] ${stepId} push failed:`, err.message);
@@ -1314,31 +1270,28 @@ async function executeStep(step, serverUrl, token, tunnel) {
     const donePayload = () => ({ text: stream.getFullText(), modelId: step.agent.modelId || model.id, commitSha, sessionLeafEntryId, diffHash });
     const images = await downloadStepImages(step);
     try {
-      await session.prompt(fullPrompt, images.length ? { images } : void 0);
-      stream.dispose();
-      stream.flush();
-      await flushChain;
+      await session.prompt(step.prompt, images.length ? { images } : void 0);
+      await stream.idle();
       const modelError = !stream.getFullText() && stream.getLastModelError();
       if (!ephemeral) await backupSession(conversationId, session.sessionFile, step.sessionBackupUrl);
       if (modelError) {
-        await done2({ error: modelError });
+        await done({ error: modelError });
       } else {
         await captureCheckpoint();
-        await done2(donePayload());
+        await done(donePayload());
       }
     } catch (err) {
-      stream.dispose();
-      await flushChain.catch(() => {
+      await stream.idle().catch(() => {
       });
       if (!ephemeral) await backupSession(conversationId, session.sessionFile, step.sessionBackupUrl);
       if (interrupted) {
         console.log(`[step] ${stepId} interrupted \u2014 saving partial content`);
         await captureCheckpoint();
-        await done2(donePayload());
+        await done(donePayload());
       } else {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`[step] ${stepId} failed:`, msg);
-        await done2({ error: msg });
+        await done({ error: msg });
       }
     } finally {
       stream.dispose();
@@ -1348,15 +1301,15 @@ async function executeStep(step, serverUrl, token, tunnel) {
   }
 }
 async function executeRestore(step, serverUrl, token) {
-  const { stepId, conversationId, agent: { agentId } } = step;
+  const { stepId, conversationId } = step;
   console.log(`[restore] ${stepId} start (conv ${conversationId})`);
-  const done2 = makeDone(serverUrl, stepId, agentId, conversationId, token);
+  const done = makeDone(step, serverUrl, token);
   let diffHash;
   const rewindCode = async () => {
     const cwd = await prepareStepWorkspace(step);
     if (!cwd || !step.workspace) return;
-    const { repoFullName, defaultBranch, installationToken } = step.workspace;
-    await pushBranch(cwd, repoFullName, installationToken, `tds/conv-${conversationId}`);
+    const { defaultBranch, installationToken } = step.workspace;
+    await pushBranch(cwd, installationToken, `tds/conv-${conversationId}`);
     diffHash = await computeDiffHash(cwd, defaultBranch, stepId);
   };
   const rewindSession = async () => {
@@ -1368,10 +1321,10 @@ async function executeRestore(step, serverUrl, token) {
   if (failed) {
     const msg = failed.reason instanceof Error ? failed.reason.message : String(failed.reason);
     console.error(`[restore] ${stepId} failed:`, msg);
-    await done2({ error: msg });
+    await done({ error: msg });
     return;
   }
-  await done2({ diffHash });
+  await done({ diffHash });
   console.log(`[restore] ${stepId} done`);
 }
 
@@ -16067,13 +16020,8 @@ var STEP_DEF = {
   plan_review: { track: "plan", sink: "review" },
   implement_review: { track: "implement", sink: "review" }
 };
-var STEP_PHASE = {
-  plan: STEP_DEF.plan.phase,
-  plan_revision: STEP_DEF.plan_revision.phase,
-  implement: STEP_DEF.implement.phase,
-  implement_revision: STEP_DEF.implement_revision.phase,
-  merge: STEP_DEF.merge.phase
-};
+var isReviewStep = (k) => STEP_DEF[k].sink === "review";
+var REVIEW_STEP_KINDS = Object.keys(STEP_DEF).filter(isReviewStep);
 var CreateTeamRequestSchema = external_exports.object({
   name: external_exports.string().trim().min(1)
 });
@@ -16083,7 +16031,8 @@ var UpdateTeamRequestSchema = external_exports.object({
 });
 var UpdateProjectRequestSchema = external_exports.object({
   name: external_exports.string().min(1).optional(),
-  description: external_exports.string().optional()
+  description: external_exports.string().optional(),
+  defaultBranch: external_exports.string().min(1).optional()
 });
 var UpdateUserProfileRequestSchema = external_exports.object({
   name: external_exports.string().trim().optional(),
@@ -16124,7 +16073,10 @@ var CreateTodoRequestSchema = external_exports.object({
   // Spec is optional: a title-only todo is allowed (the UI flags the missing spec).
   spec: external_exports.string().trim().default(""),
   tagIds: external_exports.array(external_exports.string()).optional(),
-  orderIndex: external_exports.number().optional()
+  orderIndex: external_exports.number().optional(),
+  // Birth phase — idle states only (a build is still a separate, explicit action). Defaults to
+  // 'todo'; 'idea' lets a duplicate of a parked idea land straight in the idea library.
+  phase: external_exports.enum(["todo", "idea"]).optional()
 });
 var AgentEntrySchema = external_exports.object({
   agentId: external_exports.string(),
@@ -16239,6 +16191,12 @@ var PollClient = class {
   roles = [];
   tunnel;
   onRolesChanged;
+  // Per-mount mirror health provider (set while the runner role is active). Rides the presence
+  // heartbeat so the server can tell a dead mirror from a healthy one; null omits the field.
+  getMountSync;
+  // Desired mounts pushed back on the presence response (runner machines only) — presence is the
+  // runner's single poll; the SyncManager forwards the set to the mirror daemon.
+  onMounts;
   // Only a builder claims and runs build steps; a runner-only machine still reports presence.
   get canClaim() {
     return this.roles.includes("builder");
@@ -16347,6 +16305,8 @@ ${node.sshHostKey}` : null };
   async reportPresence() {
     try {
       const body = { load: this.runningTasks.size };
+      const mountSync = this.getMountSync?.();
+      if (mountSync) body.mountSync = mountSync;
       const { node, key } = this.tunnelSnapshot();
       if (key !== this.lastSentTunnelKey) {
         body.sshHostKey = node?.sshHostKey ?? null;
@@ -16369,8 +16329,9 @@ ${node.sshHostKey}` : null };
         if (Array.isArray(data?.roles)) {
           this.setRoles(data.roles.filter((r) => r === "builder" || r === "runner"));
         }
+        if (Array.isArray(data?.mounts)) this.onMounts?.(data.mounts);
+        this.lastSentTunnelKey = key;
       }
-      this.lastSentTunnelKey = key;
     } catch {
     }
   }
@@ -16397,9 +16358,7 @@ ${node.sshHostKey}` : null };
     try {
       while (this.running && this.canClaim) {
         try {
-          if (this.maxConcurrentTasks == null) await this.reportPresence();
-          const maxConcurrentTasks = this.maxConcurrentTasks;
-          if (maxConcurrentTasks == null) throw new Error("Missing server maxConcurrentTasks");
+          const maxConcurrentTasks = this.maxConcurrentTasks ?? 1;
           if (this.runningTasks.size >= maxConcurrentTasks) {
             await Promise.race([...this.runningTasks.values(), sleep(2e3, this.abortController.signal)]);
             continue;
@@ -16454,13 +16413,10 @@ function sleep(ms, signal) {
 }
 
 // src/SyncManager.ts
-var import_node_fs6 = require("node:fs");
+var import_node_child_process2 = require("node:child_process");
 var import_node_os4 = require("node:os");
 var import_node_path6 = require("node:path");
 
-// src/lib/mirror.ts
-var import_node_child_process2 = require("node:child_process");
-
 // src/lib/bin.ts
 var import_node_fs5 = require("node:fs");
 var import_node_path5 = require("node:path");
@@ -16500,6 +16456,7 @@ function resolveBin(name) {
       dir = parent;
     }
   }
+  console.warn(`[bin] ${name} binary not found (no @todos-dev/cli-${process.platform}-${process.arch} package, no vendor/ tree near ${__dirname}) \u2014 falling back to PATH. Run \`pnpm vendor:bins\` (dev) or reinstall the CLI.`);
   return name;
 }
 var TUNNEL_BIN = resolveBin("tds-tunnel");
@@ -16525,144 +16482,127 @@ function createNdjsonParser(onEvent) {
   };
 }
 
-// src/lib/mirror.ts
-function spawnMirror(opts) {
-  const proc = (0, import_node_child_process2.spawn)(TUNNEL_BIN, [
-    "connect",
-    "--server",
-    opts.serverUrl,
-    "--token",
-    opts.token,
-    "--conversation",
-    opts.buildId,
-    "--dest",
-    opts.dest,
-    "--default-branch",
-    opts.defaultBranch,
-    "--machine",
-    opts.machineId,
-    ...opts.allowExec ? ["--allow-exec"] : []
-  ], { stdio: ["ignore", "pipe", "inherit"] });
-  if (opts.onEvent) {
-    const parse3 = createNdjsonParser(opts.onEvent);
-    proc.stdout?.on("data", (d) => parse3(String(d)));
-  }
-  const exited = new Promise((resolve) => {
-    proc.on("exit", (code) => resolve(code ?? 0));
-    proc.on("error", (err) => {
-      opts.onEvent?.({ event: "error", message: err.message });
-      resolve(1);
-    });
-  });
-  return {
-    exited,
-    stop: async () => {
-      if (proc.exitCode === null) proc.kill();
-      await exited;
-    }
-  };
-}
-
 // src/SyncManager.ts
-var RECONCILE_INTERVAL_MS = 8e3;
+var RESTART_MIN_MS = 1e3;
+var RESTART_MAX_MS = 6e4;
 function expandHome(p) {
   if (p === "~") return (0, import_node_os4.homedir)();
   if (p.startsWith("~/") || p.startsWith("~\\")) return (0, import_node_path6.join)((0, import_node_os4.homedir)(), p.slice(2));
   return p;
 }
 var SyncManager = class {
-  // keyed by mountId
+  // by mountId
   constructor(serverUrl, token, machineId) {
     this.serverUrl = serverUrl;
     this.token = token;
     this.machineId = machineId;
   }
-  timer = null;
-  running = false;
-  tunnels = /* @__PURE__ */ new Map();
+  proc = null;
+  stopped = false;
+  restartTimer = null;
+  restartDelayMs = RESTART_MIN_MS;
+  desired = [];
+  health = /* @__PURE__ */ new Map();
   start() {
-    if (this.running) return;
-    this.running = true;
+    this.stopped = false;
     console.log(`[machine] runner: managing worktree mirrors (machineId=${this.machineId})`);
-    const tick = () => {
-      void this.reconcile();
-    };
-    tick();
-    this.timer = setInterval(tick, RECONCILE_INTERVAL_MS);
+    this.spawnSidecar();
   }
   stop() {
-    this.running = false;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
+    this.stopped = true;
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
     }
-    for (const mountId of [...this.tunnels.keys()]) this.teardown(mountId);
+    this.proc?.kill();
+    this.proc = null;
   }
-  // Default dir for a mount with no explicit destDir, under the runner's home. e.g. ~/.tds/runner/owner/repo/119
-  defaultDest(m) {
-    return (0, import_node_path6.join)((0, import_node_os4.homedir)(), defaultMirrorSubpath(m.repoFullName, m.seqNum));
+  // Desired mounts, straight off the presence response. Declarative: resolve dests, remember the
+  // set (a respawned daemon gets it replayed on its 'up' event), and forward it.
+  setMounts(resolved) {
+    this.desired = resolved.map((r) => ({
+      mountId: r.mountId,
+      buildId: r.buildId,
+      dest: r.destDir ? expandHome(r.destDir) : (0, import_node_path6.join)((0, import_node_os4.homedir)(), defaultMirrorSubpath(r.repoFullName, r.seqNum)),
+      defaultBranch: r.defaultBranch,
+      allowExec: r.allowExec
+    }));
+    const keep = new Set(this.desired.map((m) => m.mountId));
+    for (const id of [...this.health.keys()]) if (!keep.has(id)) this.health.delete(id);
+    this.sendMounts();
+  }
+  // Per-mount mirror health for the presence heartbeat: age of the last completed cycle (computed
+  // here so no other machine ever compares clocks) + last error. The web mounts panel and sync
+  // indicator read this — presence alone can't tell a dead mirror from a healthy one.
+  status() {
+    const now = Date.now();
+    return this.desired.map((m) => {
+      const h = this.health.get(m.mountId);
+      return {
+        mountId: m.mountId,
+        ageMs: h?.syncedAt ? now - h.syncedAt : null,
+        ...h?.lastError ? { error: h.lastError } : {}
+      };
+    });
   }
-  async fetchMounts() {
+  spawnSidecar() {
     try {
-      const res = await fetch(`${this.serverUrl}/api/machine/mounts`, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${this.token}` },
-        signal: AbortSignal.timeout(8e3)
-      });
-      if (!res.ok) return null;
-      return await res.json();
+      this.proc = (0, import_node_child_process2.spawn)(
+        TUNNEL_BIN,
+        ["mirror", "--server", this.serverUrl, "--token", this.token, "--machine", this.machineId],
+        // stdin is piped: the desired mount set goes down as NDJSON control messages.
+        { stdio: ["pipe", "pipe", "inherit"] }
+      );
     } catch {
-      return null;
-    }
-  }
-  async reconcile() {
-    if (!this.running) return;
-    const resolved = await this.fetchMounts();
-    if (resolved === null) return;
-    const desired = new Map(resolved.map((r) => [r.mountId, r]));
-    for (const [mountId, t] of [...this.tunnels]) {
-      const want = desired.get(mountId);
-      if (!want || want.buildId !== t.buildId || want.allowExec !== t.allowExec) this.teardown(mountId);
-    }
-    for (const r of resolved) {
-      if (!this.tunnels.has(r.mountId)) this.startTunnel(r);
-    }
-  }
-  startTunnel(r) {
-    const dest = r.destDir ? expandHome(r.destDir) : this.defaultDest(r);
-    try {
-      (0, import_node_fs6.mkdirSync)(dest, { recursive: true });
-    } catch (e) {
-      console.warn(`[machine] runner: cannot create ${dest}: ${e.message} \u2014 skipping mount ${r.mountId}`);
+      console.warn("[machine] runner: tds-tunnel not available \u2014 mirroring disabled");
       return;
     }
-    console.log(`[machine] runner: mirroring #${r.seqNum} (build ${r.buildId.slice(0, 8)}) \u2192 ${dest}${r.allowExec ? " [exec]" : ""}`);
-    const handle = spawnMirror({
-      serverUrl: this.serverUrl,
-      token: this.token,
-      buildId: r.buildId,
-      dest,
-      defaultBranch: r.defaultBranch,
-      machineId: this.machineId,
-      allowExec: r.allowExec,
-      onEvent: (e) => {
-        if (e.event === "error") console.warn(`[machine] runner: mount ${r.mountId}: ${e.message ?? "error"}`);
-        else if (e.event === "synced" && (e.changed || e.deleted)) {
-          console.log(`[machine] runner: #${r.seqNum} \u2193 ${e.changed ?? 0} changed, ${e.deleted ?? 0} deleted`);
-        }
-      }
+    this.proc.on("error", () => {
+      console.warn("[machine] runner: mirror daemon failed to start \u2014 mirroring disabled");
+      this.proc = null;
+    });
+    this.proc.on("exit", () => {
+      this.proc = null;
+      this.scheduleRestart();
     });
-    this.tunnels.set(r.mountId, { buildId: r.buildId, allowExec: r.allowExec, handle });
-    void handle.exited.then(() => {
-      const cur = this.tunnels.get(r.mountId);
-      if (cur && cur.handle === handle) this.tunnels.delete(r.mountId);
+    this.proc.stdout?.on("data", (d) => this.onStdout(String(d)));
+    this.proc.stdin?.on("error", () => {
     });
   }
-  teardown(mountId) {
-    const t = this.tunnels.get(mountId);
-    if (!t) return;
-    this.tunnels.delete(mountId);
-    void t.handle.stop();
+  scheduleRestart() {
+    if (this.stopped || this.restartTimer) return;
+    const delay2 = this.restartDelayMs;
+    this.restartDelayMs = Math.min(this.restartDelayMs * 2, RESTART_MAX_MS);
+    console.warn(`[machine] runner: mirror daemon exited \u2014 restarting in ${Math.round(delay2 / 1e3)}s`);
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      this.spawnSidecar();
+    }, delay2);
+  }
+  onStdout = createNdjsonParser((e) => {
+    if (e.event === "up") {
+      this.restartDelayMs = RESTART_MIN_MS;
+      this.sendMounts();
+    } else if (e.event === "synced" && e.mount) {
+      this.health.set(e.mount, { syncedAt: Date.now(), lastError: null });
+      if (e.changed || e.deleted) console.log(`[machine] runner: mount ${e.mount} \u2193 ${e.changed ?? 0} changed, ${e.deleted ?? 0} deleted`);
+    } else if (e.event === "error") {
+      if (e.mount) {
+        const h = this.health.get(e.mount);
+        this.health.set(e.mount, { syncedAt: h?.syncedAt ?? 0, lastError: e.message ?? "error" });
+        console.warn(`[machine] runner: mount ${e.mount}: ${e.message ?? "error"}`);
+      } else {
+        console.warn(`[machine] runner: ${e.message ?? "error"}`);
+      }
+    }
+  });
+  sendMounts() {
+    const stdin = this.proc?.stdin;
+    if (!stdin || stdin.destroyed) return;
+    try {
+      stdin.write(JSON.stringify({ cmd: "mounts", mounts: this.desired }) + "\n");
+    } catch {
+    }
   }
 };
 
@@ -16776,6 +16716,9 @@ async function syncModelsToServer(serverUrl, token, runtime) {
 // src/lib/tunnel.ts
 var import_node_child_process3 = require("node:child_process");
 var SHELL_BUFFER_CAP = 256 * 1024;
+var RESTART_MIN_MS2 = 1e3;
+var RESTART_MAX_MS2 = 6e4;
+var EMPTY_BUFFER = Buffer.alloc(0);
 var TunnelServer = class _TunnelServer {
   constructor(serverUrl, token) {
     this.serverUrl = serverUrl;
@@ -16784,14 +16727,13 @@ var TunnelServer = class _TunnelServer {
   proc = null;
   node = null;
   onChange = null;
-  // Reverse-shell subscribers, keyed by (build, machine) — a build mirrored onto several runners has
-  // one shell per machine. The agent's client_shell tool subscribes while it drives one; sidecar
-  // shell-output/shell-closed events fan out to them.
-  shellListeners = /* @__PURE__ */ new Map();
-  // Buffered PTY output per (build, machine), drained by the tool. Recorded even with no live
-  // subscriber so output a backgrounded command emits between tool calls survives until the next drain.
-  shellBuffers = /* @__PURE__ */ new Map();
-  closedShells = /* @__PURE__ */ new Set();
+  stopped = false;
+  restartTimer = null;
+  restartDelayMs = RESTART_MIN_MS2;
+  // Reverse shells, keyed by (build, machine) — a build mirrored onto several runners has one shell
+  // per machine. Output is buffered even with no live subscriber so output a backgrounded command
+  // emits between tool calls survives until the next drain.
+  shells = /* @__PURE__ */ new Map();
   // Set the single handler fired whenever the tunnel node appears/changes/clears, so presence can
   // be pushed immediately instead of waiting for the next heartbeat tick. Fires now if already ready.
   setNodeChangeHandler(cb) {
@@ -16799,6 +16741,10 @@ var TunnelServer = class _TunnelServer {
     if (this.node) cb();
   }
   start() {
+    this.stopped = false;
+    this.spawnSidecar();
+  }
+  spawnSidecar() {
     try {
       this.proc = (0, import_node_child_process3.spawn)(
         TUNNEL_BIN,
@@ -16819,11 +16765,22 @@ var TunnelServer = class _TunnelServer {
       this.node = null;
       this.closeAllShells();
       this.onChange?.();
+      this.scheduleRestart();
     });
     this.proc.stdout?.on("data", (d) => this.onStdout(String(d)));
     this.proc.stdin?.on("error", () => {
     });
   }
+  scheduleRestart() {
+    if (this.stopped || this.restartTimer) return;
+    const delay2 = this.restartDelayMs;
+    this.restartDelayMs = Math.min(this.restartDelayMs * 2, RESTART_MAX_MS2);
+    console.warn(`[tunnel] sidecar exited \u2014 restarting in ${Math.round(delay2 / 1e3)}s`);
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      this.spawnSidecar();
+    }, delay2);
+  }
   // Reverse-shell map key: a build mirrored onto several runners has one shell per machine.
   static shellKey(build, machine) {
     return `${build}\0${machine}`;
@@ -16833,19 +16790,26 @@ var TunnelServer = class _TunnelServer {
   onStdout = createNdjsonParser((evt) => {
     if (evt.event === "ready" && evt.tailnetAddr && evt.sshHostKey) {
       this.node = { tailnetAddr: evt.tailnetAddr, sshHostKey: evt.sshHostKey };
+      this.restartDelayMs = RESTART_MIN_MS2;
       console.log(`[tunnel] ready (tailnet ${evt.tailnetAddr})`);
       this.onChange?.();
     } else if ((evt.event === "shell-opened" || evt.event === "shell-output" || evt.event === "shell-closed") && evt.build) {
-      const key = _TunnelServer.shellKey(evt.build, evt.machine ?? "");
+      const s = this.shellState(_TunnelServer.shellKey(evt.build, evt.machine ?? ""));
       if (evt.event === "shell-opened") {
-        this.closedShells.delete(key);
+        s.connected = true;
+        s.closed = false;
+        s.gen++;
       } else if (evt.event === "shell-output") {
-        this.appendShellBuffer(key, Buffer.from(evt.data ?? "", "base64"));
-        for (const l of this.shellListeners.get(key) ?? []) l.onActivity();
+        s.connected = true;
+        s.closed = false;
+        let next = Buffer.concat([s.buffer, Buffer.from(evt.data ?? "", "base64")]);
+        if (next.length > SHELL_BUFFER_CAP) next = next.subarray(next.length - SHELL_BUFFER_CAP);
+        s.buffer = next;
+        for (const l of s.listeners) l.onActivity();
       } else {
-        this.closedShells.add(key);
-        const subs = [...this.shellListeners.get(key) ?? []];
-        for (const l of subs) l.onClosed();
+        s.connected = false;
+        s.closed = true;
+        for (const l of [...s.listeners]) l.onClosed();
       }
     } else if (evt.event === "error") {
       console.warn(`[tunnel] ${evt.message ?? "error"}`);
@@ -16872,52 +16836,66 @@ var TunnelServer = class _TunnelServer {
   shellSendInput(build, machine, data) {
     return this.writeControl({ cmd: "shell-input", build, machine, data: Buffer.from(data, "utf8").toString("base64") });
   }
-  shellClosed(build, machine) {
-    return this.closedShells.has(_TunnelServer.shellKey(build, machine));
+  // Whether the client's shell channel is currently registered sidecar-side. undefined = no event
+  // seen yet for this key (a client may still be connected — input discovers it); false = it was
+  // there and dropped (or input bounced), so the tool fails fast instead of timing out.
+  shellConnected(build, machine) {
+    return this.shells.get(_TunnelServer.shellKey(build, machine))?.connected;
+  }
+  // True once per PTY replacement: the shell reconnected (new session, prior state lost) since the
+  // tool last consumed this flag. The first-ever open is not a "reconnect".
+  consumeShellReconnect(build, machine) {
+    const s = this.shells.get(_TunnelServer.shellKey(build, machine));
+    if (!s) return false;
+    const reconnected = s.reportedGen >= 1 && s.gen > s.reportedGen;
+    s.reportedGen = s.gen;
+    return reconnected;
   }
   subscribeShell(build, machine, l) {
-    const key = _TunnelServer.shellKey(build, machine);
-    let set2 = this.shellListeners.get(key);
-    if (!set2) {
-      set2 = /* @__PURE__ */ new Set();
-      this.shellListeners.set(key, set2);
-    }
-    set2.add(l);
+    const s = this.shellState(_TunnelServer.shellKey(build, machine));
+    s.listeners.add(l);
     return () => {
-      const s = this.shellListeners.get(key);
-      if (!s) return;
-      s.delete(l);
-      if (s.size === 0) this.shellListeners.delete(key);
+      s.listeners.delete(l);
     };
   }
   // Return and clear a (build, machine) shell's buffered PTY output (UTF-8). The tool calls this
-  // after a quiet period to get everything the shell printed since the last drain.
+  // after a quiet period to get everything the shell printed since the last drain; the closed
+  // marker is cleared too so the next session for this key starts fresh. The entry itself is kept —
+  // connected/gen are cross-call memory (tiny, bounded by builds this daemon has served).
   drainShell(build, machine) {
-    const key = _TunnelServer.shellKey(build, machine);
-    const buf = this.shellBuffers.get(key);
-    this.closedShells.delete(key);
-    if (!buf || buf.length === 0) return "";
-    this.shellBuffers.delete(key);
-    return buf.toString("utf8");
-  }
-  appendShellBuffer(key, chunk) {
-    this.closedShells.delete(key);
-    const prev = this.shellBuffers.get(key);
-    let next = prev ? Buffer.concat([prev, chunk]) : chunk;
-    if (next.length > SHELL_BUFFER_CAP) next = next.subarray(next.length - SHELL_BUFFER_CAP);
-    this.shellBuffers.set(key, next);
-  }
+    const s = this.shells.get(_TunnelServer.shellKey(build, machine));
+    if (!s) return "";
+    const out = s.buffer.toString("utf8");
+    s.buffer = EMPTY_BUFFER;
+    s.closed = false;
+    return out;
+  }
+  shellState(key) {
+    let s = this.shells.get(key);
+    if (!s) {
+      s = { buffer: EMPTY_BUFFER, closed: false, gen: 0, reportedGen: 0, listeners: /* @__PURE__ */ new Set() };
+      this.shells.set(key, s);
+    }
+    return s;
+  }
+  // Sidecar death takes every client connection with it. Entries survive (not cleared) so the
+  // shells' reconnect generations still tick when clients re-register against the respawned sidecar.
   closeAllShells() {
-    const all = [...this.shellListeners.values()].flatMap((s) => [...s]);
-    this.shellListeners.clear();
-    for (const l of all) l.onClosed();
-    this.closedShells.clear();
-    this.shellBuffers.clear();
+    for (const s of this.shells.values()) {
+      s.connected = false;
+      s.closed = true;
+      for (const l of [...s.listeners]) l.onClosed();
+    }
   }
   current() {
     return this.node;
   }
   stop() {
+    this.stopped = true;
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
+    }
     this.proc?.kill();
     this.proc = null;
     this.node = null;
@@ -16927,7 +16905,7 @@ var TunnelServer = class _TunnelServer {
 
 // src/lib/flagParser.ts
 var REPEATABLE = /* @__PURE__ */ new Set(["model"]);
-function parseFlags(args2) {
+function parseFlags(args2, shortFlags = {}) {
   const flags = {};
   const repeated = {};
   const bools = {};
@@ -16935,12 +16913,9 @@ function parseFlags(args2) {
   for (let i = 0; i < args2.length; i++) {
     const a = args2[i];
     if (!a.startsWith("--")) {
-      if (a === "-y") {
-        bools["yes"] = true;
-        continue;
-      }
-      if (a === "-f") {
-        bools["foreground"] = true;
+      const short = a.startsWith("-") ? shortFlags[a.slice(1)] : void 0;
+      if (short) {
+        bools[short] = true;
         continue;
       }
       positionals.push(a);
@@ -16979,7 +16954,7 @@ function assign(key, value, flags, repeated) {
 
 // src/commands/start.ts
 async function startCommand(args2) {
-  const { flags, bools } = parseFlags(args2);
+  const { flags, bools } = parseFlags(args2, { f: "foreground" });
   if (bools.supervisor) return runSupervisor(args2);
   if (bools.foreground) {
     const { config: config2, serverUrl } = await ensureEnrolled(flags);
@@ -17103,16 +17078,24 @@ async function runWorker(config2, serverUrl) {
     tunnel = void 0;
     client.setTunnel(void 0);
   };
+  let lastMounts = [];
+  client.onMounts = (mounts) => {
+    lastMounts = mounts;
+    syncManager?.setMounts(mounts);
+  };
   const enableRunner = () => {
     if (syncManager) return;
     syncManager = new SyncManager(serverUrl, cfg.token, cfg.machineId);
     syncManager.start();
+    syncManager.setMounts(lastMounts);
+    client.getMountSync = () => syncManager?.status() ?? null;
   };
   const disableRunner = () => {
     if (!syncManager) return;
     console.log("[machine] Disabling runner: stopping worktree mirrors.");
     syncManager.stop();
     syncManager = void 0;
+    client.getMountSync = void 0;
   };
   async function applyRoles(roles) {
     if (roles.includes("builder")) {
@@ -17182,13 +17165,13 @@ async function restartCommand(args2) {
 var import_child_process4 = require("child_process");
 var import_fs5 = require("fs");
 async function logsCommand(args2) {
-  const { bools } = parseFlags(args2);
+  const { bools } = parseFlags(args2, { f: "follow" });
   const p = logPath();
   if (!(0, import_fs5.existsSync)(p)) {
     console.log(`[tds] No log file yet (${p}). Run 'tds start' first.`);
     return;
   }
-  const follow = bools.foreground || bools.follow;
+  const follow = bools.follow;
   console.error(`[tds] ${p}`);
   const tailArgs = follow ? ["-f", p] : ["-n", "200", p];
   const child = (0, import_child_process4.spawn)("tail", tailArgs, { stdio: ["ignore", "inherit", "inherit"] });
@@ -17245,7 +17228,7 @@ function renderTabBar(tabs, active) {
     return i === active ? import_yoctocolors_cjs.default.inverse(import_yoctocolors_cjs.default.cyan(label)) : import_yoctocolors_cjs.default.dim(label);
   }).join(" ");
 }
-var tabbedSearchPrompt = (0, import_core8.createPrompt)((config2, done2) => {
+var tabbedSearchPrompt = (0, import_core8.createPrompt)((config2, done) => {
   const { tabs } = config2;
   const pageSize = config2.pageSize ?? 8;
   const theme = (0, import_core8.makeTheme)({});
@@ -17266,7 +17249,7 @@ var tabbedSearchPrompt = (0, import_core8.createPrompt)((config2, done2) => {
     if ((0, import_core8.isEnterKey)(key)) {
       if (!selected) return;
       setStatus("done");
-      done2(selected.value);
+      done(selected.value);
       return;
     }
     if (key.name === "left" || key.name === "right") {
@@ -17450,16 +17433,16 @@ function findPreset(presets, id) {
 }
 
 // src/lib/modelsJson.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs6 = require("node:fs");
 var import_node_path7 = require("node:path");
 function modelsJsonPath(agentDir) {
   return (0, import_node_path7.join)(agentDir, "models.json");
 }
 function readModelsJson(agentDir) {
   const p = modelsJsonPath(agentDir);
-  if (!(0, import_node_fs7.existsSync)(p)) return { providers: {} };
+  if (!(0, import_node_fs6.existsSync)(p)) return { providers: {} };
   try {
-    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(p, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(p, "utf-8"));
     return { providers: parsed.providers ?? {} };
   } catch (e) {
     throw new Error(`Failed to parse ${p}: ${e.message}`);
@@ -17467,8 +17450,8 @@ function readModelsJson(agentDir) {
 }
 function writeModelsJson(agentDir, config2) {
   const p = modelsJsonPath(agentDir);
-  (0, import_node_fs7.mkdirSync)((0, import_node_path7.dirname)(p), { recursive: true });
-  (0, import_node_fs7.writeFileSync)(p, JSON.stringify(config2, null, 2) + "\n", { mode: 384 });
+  (0, import_node_fs6.mkdirSync)((0, import_node_path7.dirname)(p), { recursive: true });
+  (0, import_node_fs6.writeFileSync)(p, JSON.stringify(config2, null, 2) + "\n", { mode: 384 });
 }
 function upsertProvider(config2, name, entry) {
   return { providers: { ...config2.providers, [name]: entry } };
@@ -17556,7 +17539,7 @@ async function menu() {
   }
 }
 async function addProvider(args2) {
-  const parsed = parseFlags(args2);
+  const parsed = parseFlags(args2, { y: "yes" });
   const yes = parsed.bools["yes"] === true;
   const runtime = await getPiRuntime();
   const presets = buildPresets(runtime.builtinProviderIds, runtime.displayNameFor);
@@ -17703,7 +17686,7 @@ async function listProviders(args2) {
   }
 }
 async function removeProvider2(args2) {
-  const { positionals, bools } = parseFlags(args2);
+  const { positionals, bools } = parseFlags(args2, { y: "yes" });
   const yes = bools["yes"] === true;
   const runtime = await getPiRuntime();
   const { authStorage } = runtime;
@@ -17808,6 +17791,8 @@ async function logoutCommand() {
 // src/index.ts
 var COMMANDS = {
   start: {
+    run: startCommand,
+    longLived: true,
     summary: "Bring this machine online in the background (enroll if needed)",
     help: `Usage: tds start [options]
 
@@ -17831,6 +17816,7 @@ Options:
   --server <url>    Override the server URL`
   },
   stop: {
+    run: () => stopCommand(),
     summary: "Stop the background machine",
     help: `Usage: tds stop
 
@@ -17838,6 +17824,8 @@ Stop the background daemon started by 'tds start'. Sends SIGTERM so in-flight ta
 shut down cleanly; SIGKILLs only if it doesn't exit in time.`
   },
   restart: {
+    run: restartCommand,
+    longLived: true,
     summary: "Restart the background machine",
     help: `Usage: tds restart [options]
 
@@ -17845,6 +17833,7 @@ Stop the background daemon (if running) and start it again in the background. Ta
 same options as 'tds start'.`
   },
   logs: {
+    run: logsCommand,
     summary: "Show the background machine's logs",
     help: `Usage: tds logs [-f]
 
@@ -17854,6 +17843,7 @@ Options:
   -f, --follow   Follow the log as it grows (like 'tail -f')`
   },
   logout: {
+    run: () => logoutCommand(),
     summary: "Forget this machine's local registration",
     help: `Usage: tds logout
 
@@ -17862,12 +17852,14 @@ Stop the background daemon (if running), then clear ~/.tds/machine.json so the n
 (an admin does that in the web UI).`
   },
   status: {
+    run: () => statusCommand(),
     summary: "Show this machine's registration and status",
     help: `Usage: tds status
 
 Show this machine's registration and current status.`
   },
   provider: {
+    run: providerCommand,
     summary: "Manage AI providers and models",
     help: `Usage: tds provider <add|list|remove|login> [options]
 
@@ -17896,38 +17888,14 @@ if (COMMANDS[cmd] && (rest.includes("--help") || rest.includes("-h"))) {
   console.log(COMMANDS[cmd].help);
   process.exit(0);
 }
-switch (cmd) {
-  // One-shot commands: exit explicitly when done (fetch keep-alive sockets block natural exit).
-  case "logout":
-    logoutCommand().then(done).catch(fatal);
-    break;
-  case "status":
-    statusCommand().then(done).catch(fatal);
-    break;
-  case "provider":
-    providerCommand(rest).then(done).catch(fatal);
-    break;
-  case "stop":
-    stopCommand().then(done).catch(fatal);
-    break;
-  case "logs":
-    logsCommand(rest).then(done).catch(fatal);
-    break;
-  // start/restart self-detach (exit after launching) or run long-lived (--foreground/--supervisor).
-  case "start":
-    startCommand(rest).catch(fatal);
-    break;
-  case "restart":
-    restartCommand(rest).catch(fatal);
-    break;
-  default:
-    console.error(`[tds] Unknown command: ${cmd}`);
-    printHelp();
-    process.exit(1);
-}
-function done() {
-  process.exit(0);
+var command = COMMANDS[cmd];
+if (!command) {
+  console.error(`[tds] Unknown command: ${cmd}`);
+  printHelp();
+  process.exit(1);
 }
+if (command.longLived) command.run(rest).catch(fatal);
+else command.run(rest).then(() => process.exit(0)).catch(fatal);
 function fatal(err) {
   console.error("[tds] Fatal:", err.message);
   process.exit(1);