@todos-dev/cli 0.1.2 → 0.1.4

package/dist/index.js

@@ -361,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: {
@@ -384,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;
@@ -403,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 = () => {
@@ -423,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 {
@@ -443,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) {
@@ -454,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 };
@@ -498,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);
     }
@@ -550,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
@@ -897,7 +923,7 @@ async function postCritical(serverUrl, path, body, token) {
     `[machine] POST ${path}`
   );
 }
-function startHeartbeat(serverUrl, stepId, agentId, onSignal, token) {
+function startHeartbeat(serverUrl, stepId, agentId, onSignal, token, onRunners) {
   let active = true;
   let inFlight = false;
   const tick = async () => {
@@ -906,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;
     }
@@ -1087,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}` } : {}
   );
 }
@@ -1152,7 +1179,10 @@ async function executeStep(step, serverUrl, token, tunnel) {
     interrupted = true;
     abortRef?.abort();
   };
-  const stopHeartbeat = startHeartbeat(serverUrl, stepId, agentId, stopTurn, 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();
@@ -1171,14 +1201,6 @@ async function executeStep(step, serverUrl, token, tunnel) {
       await done({ error: `Workspace preparation failed: ${err.message}` });
       return;
     }
-    if (step.restore) {
-      try {
-        await restoreSessionToCheckpoint(step);
-      } catch (err) {
-        await done({ error: `Session rewind failed: ${err.message}` });
-        return;
-      }
-    }
     const ephemeral = step.mode === "ephemeral_turn";
     const m = ephemeral ? { sessionManager: sdk.SessionManager.inMemory(cwd), isContinue: false, sessionKeyForSave: null } : await materializeSession({
       sdk,
@@ -1189,7 +1211,7 @@ async function executeStep(step, serverUrl, token, tunnel) {
     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, {
@@ -1345,6 +1367,18 @@ function clearConfig() {
   }
 }
 
+// src/lib/log.ts
+var installed = false;
+function installTimestampedLogging() {
+  if (installed) return;
+  installed = true;
+  const stamp = () => `[${(/* @__PURE__ */ new Date()).toISOString()}]`;
+  for (const method of ["log", "info", "warn", "error", "debug"]) {
+    const orig = console[method].bind(console);
+    console[method] = (...args2) => orig(stamp(), ...args2);
+  }
+}
+
 // src/lib/daemon.ts
 var LOG_CAP = 10 * 1024 * 1024;
 var EXIT_TERMINAL = 78;
@@ -1409,6 +1443,7 @@ function spawnSupervisor(userArgs, logFd) {
 var MODE_FLAGS = /* @__PURE__ */ new Set(["--supervisor", "--foreground", "-f"]);
 var userFlagsOnly = (args2) => args2.filter((a) => !MODE_FLAGS.has(a));
 async function runSupervisor(args2) {
+  installTimestampedLogging();
   const userArgs = userFlagsOnly(args2);
   const MAX_BACKOFF = 3e4;
   const STABLE_MS = 6e4;
@@ -14151,14 +14186,14 @@ var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 var _installedGroups = /* @__PURE__ */ new WeakMap();
 function _installLazyMethods(inst, group, methods) {
   const proto = Object.getPrototypeOf(inst);
-  let installed = _installedGroups.get(proto);
-  if (!installed) {
-    installed = /* @__PURE__ */ new Set();
-    _installedGroups.set(proto, installed);
+  let installed2 = _installedGroups.get(proto);
+  if (!installed2) {
+    installed2 = /* @__PURE__ */ new Set();
+    _installedGroups.set(proto, installed2);
   }
-  if (installed.has(group))
+  if (installed2.has(group))
     return;
-  installed.add(group);
+  installed2.add(group);
   for (const key in methods) {
     const fn = methods[key];
     Object.defineProperty(proto, key, {
@@ -16161,6 +16196,7 @@ var PollClient = class {
   runningTasks = /* @__PURE__ */ new Map();
   presenceTimer = null;
   gcTimer = null;
+  pokeTimer = null;
   lastSentTunnelKey;
   revoked = false;
   maxConcurrentTasks = null;
@@ -16169,6 +16205,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");
@@ -16195,6 +16237,16 @@ var PollClient = class {
     tunnel?.setNodeChangeHandler(() => void this.reportPresence());
     void this.reportPresence();
   }
+  // Out-of-cycle beat for mirror-health transitions, so the web flips within ~a second
+  // instead of waiting out the ≤20s presence tail. Debounced: a burst of transitions (daemon
+  // restart syncing every mount at once) collapses into one POST carrying the final state.
+  pokePresence() {
+    if (this.pokeTimer) return;
+    this.pokeTimer = setTimeout(() => {
+      this.pokeTimer = null;
+      void this.reportPresence();
+    }, 250);
+  }
   maybeStartClaim() {
     if (this.running && this.canClaim && !this.loopActive) {
       this.loopActive = true;
@@ -16229,6 +16281,10 @@ var PollClient = class {
       clearInterval(this.gcTimer);
       this.gcTimer = null;
     }
+    if (this.pokeTimer) {
+      clearTimeout(this.pokeTimer);
+      this.pokeTimer = null;
+    }
   }
   // The machine was removed from its team (or its token revoked): every /api/machine/* call now
   // 401/403s. Fail fast instead of spinning forever — stop and exit so the operator notices.
@@ -16277,6 +16333,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;
@@ -16299,6 +16357,7 @@ ${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;
       }
     } catch {
@@ -16382,11 +16441,10 @@ function sleep(ms, signal) {
 }
 
 // src/SyncManager.ts
-var import_node_fs6 = require("node:fs");
 var import_node_os4 = require("node:os");
 var import_node_path6 = require("node:path");
 
-// src/lib/mirror.ts
+// src/lib/sidecar.ts
 var import_node_child_process2 = require("node:child_process");
 
 // src/lib/bin.ts
@@ -16454,145 +16512,174 @@ 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,
-    "--build",
-    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/lib/sidecar.ts
+var RESTART_MIN_MS = 1e3;
+var RESTART_MAX_MS = 6e4;
+var Sidecar = class {
+  constructor(args2, label, onEvent, onExit) {
+    this.args = args2;
+    this.label = label;
+    this.onExit = onExit;
+    this.parse = createNdjsonParser(onEvent);
+  }
+  proc = null;
+  stopped = false;
+  restartTimer = null;
+  restartDelayMs = RESTART_MIN_MS;
+  parse;
+  start() {
+    this.stopped = false;
+    this.spawn();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
     }
-  };
-}
+    this.proc?.kill();
+    this.proc = null;
+  }
+  // Owner saw the sidecar's healthy signal — future crashes retry quickly again.
+  resetBackoff() {
+    this.restartDelayMs = RESTART_MIN_MS;
+  }
+  // Whether control messages can be sent at all (process up with a writable stdin).
+  alive() {
+    return Boolean(this.proc && !this.proc.killed && this.proc.stdin && !this.proc.stdin.destroyed);
+  }
+  // Write one NDJSON control message to the sidecar's stdin; false when it can't be delivered
+  // (the exit/respawn path is the recovery, so callers just skip).
+  write(msg) {
+    const stdin = this.proc?.stdin;
+    if (!stdin || stdin.destroyed) return false;
+    try {
+      stdin.write(JSON.stringify(msg) + "\n");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  spawn() {
+    try {
+      this.proc = (0, import_node_child_process2.spawn)(TUNNEL_BIN, this.args, { stdio: ["pipe", "pipe", "inherit"] });
+    } catch {
+      console.warn(`[${this.label}] tds-tunnel not available \u2014 disabled`);
+      return;
+    }
+    this.proc.on("error", () => {
+      console.warn(`[${this.label}] sidecar failed to start \u2014 disabled`);
+      this.proc = null;
+    });
+    this.proc.on("exit", () => {
+      this.proc = null;
+      this.onExit?.();
+      this.scheduleRestart();
+    });
+    this.proc.stdout?.on("data", (d) => this.parse(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_MS);
+    console.warn(`[${this.label}] sidecar exited \u2014 restarting in ${Math.round(delay2 / 1e3)}s`);
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      this.spawn();
+    }, delay2);
+  }
+};
 
 // src/SyncManager.ts
-var RECONCILE_INTERVAL_MS = 8e3;
 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 WORKTREE_REBUILD_PATIENCE_MS = 18e4;
 var SyncManager = class {
-  // keyed by mountId
   constructor(serverUrl, token, machineId) {
-    this.serverUrl = serverUrl;
-    this.token = token;
     this.machineId = machineId;
+    this.sidecar = new Sidecar(
+      ["mirror", "--server", serverUrl, "--token", token, "--machine", machineId],
+      "runner",
+      (e) => this.onEvent(e)
+    );
   }
-  timer = null;
-  running = false;
-  tunnels = /* @__PURE__ */ new Map();
+  sidecar;
+  desired = [];
+  health = /* @__PURE__ */ new Map();
+  // by mountId
+  // Fired on coarse health transitions (first cycle, error set/cleared) so the presence beat
+  // carrying the change goes out immediately instead of on the next 20s tick.
+  onHealthChanged;
   start() {
-    if (this.running) return;
-    this.running = true;
     console.log(`[machine] runner: managing worktree mirrors (machineId=${this.machineId})`);
-    const tick = () => {
-      void this.reconcile();
-    };
-    tick();
-    this.timer = setInterval(tick, RECONCILE_INTERVAL_MS);
+    this.sidecar.start();
   }
   stop() {
-    this.running = false;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    for (const mountId of [...this.tunnels.keys()]) this.teardown(mountId);
-  }
-  // 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));
-  }
-  async fetchMounts() {
-    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();
-    } catch {
-      return null;
-    }
+    this.sidecar.stop();
   }
-  async reconcile() {
-    if (!this.running) return;
-    const resolved = await this.fetchMounts();
-    if (resolved === null) return;
-    if (!this.running) 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}`);
-      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,
+  // 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,
+      dest: r.destDir ? expandHome(r.destDir) : (0, import_node_path6.join)((0, import_node_os4.homedir)(), defaultMirrorSubpath(r.repoFullName, r.seqNum)),
       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.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);
+      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 } : {}
+      };
     });
   }
-  teardown(mountId) {
-    const t = this.tunnels.get(mountId);
-    if (!t) return;
-    this.tunnels.delete(mountId);
-    void t.handle.stop();
+  onEvent(e) {
+    if (e.event === "up") {
+      this.sidecar.resetBackoff();
+      this.sendMounts();
+    } else if (e.event === "synced" && e.mount) {
+      const prev = this.health.get(e.mount);
+      this.health.set(e.mount, { syncedAt: Date.now(), lastError: null });
+      if (!prev?.syncedAt || prev.lastError) this.onHealthChanged?.();
+      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 === "worktree-missing" && e.mount) {
+      const prev = this.health.get(e.mount);
+      const missingSince = prev?.missingSince ?? Date.now();
+      const lastError = Date.now() - missingSince > WORKTREE_REBUILD_PATIENCE_MS ? e.message ?? "worktree missing" : null;
+      this.health.set(e.mount, { syncedAt: 0, lastError, missingSince });
+      if (!!prev?.syncedAt || (prev?.lastError ?? null) !== lastError) this.onHealthChanged?.();
+      console.log(`[machine] runner: mount ${e.mount}: worktree missing \u2014 rebuild requested`);
+    } else if (e.event === "error") {
+      if (e.mount) {
+        const prev = this.health.get(e.mount);
+        const message = e.message ?? "error";
+        this.health.set(e.mount, { syncedAt: prev?.syncedAt ?? 0, lastError: message });
+        if (prev?.lastError !== message) this.onHealthChanged?.();
+        console.warn(`[machine] runner: mount ${e.mount}: ${message}`);
+      } else {
+        console.warn(`[machine] runner: ${e.message ?? "error"}`);
+      }
+    }
+  }
+  sendMounts() {
+    this.sidecar.write({ cmd: "mounts", mounts: this.desired });
   }
 };
 
@@ -16704,26 +16791,30 @@ 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_MS = 1e3;
-var RESTART_MAX_MS = 6e4;
 var EMPTY_BUFFER = Buffer.alloc(0);
 var TunnelServer = class _TunnelServer {
-  constructor(serverUrl, token) {
-    this.serverUrl = serverUrl;
-    this.token = token;
-  }
-  proc = null;
   node = null;
   onChange = null;
-  stopped = false;
-  restartTimer = null;
-  restartDelayMs = RESTART_MIN_MS;
+  // Process lifecycle (spawn / respawn-with-backoff / stdin control) is the shared Sidecar's job;
+  // this class keeps only the domain state that dies with the process: node + shells.
+  sidecar;
   // 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();
+  constructor(serverUrl, token) {
+    this.sidecar = new Sidecar(
+      ["serve", "--server", serverUrl, "--token", token],
+      "tunnel",
+      (evt) => this.onEvent(evt),
+      () => {
+        this.node = null;
+        this.closeAllShells();
+        this.onChange?.();
+      }
+    );
+  }
   // 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) {
@@ -16731,99 +16822,65 @@ 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,
-        ["serve", "--server", this.serverUrl, "--token", this.token],
-        // stdin is piped (not ignored) so we can write reverse-shell control messages to the sidecar.
-        { stdio: ["pipe", "pipe", "inherit"] }
-      );
-    } catch {
-      console.warn("[tunnel] sidecar not available \u2014 runner mirroring disabled");
-      return;
-    }
-    this.proc.on("error", () => {
-      console.warn("[tunnel] sidecar failed to start \u2014 runner mirroring disabled");
-      this.proc = null;
-    });
-    this.proc.on("exit", () => {
-      this.proc = null;
-      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_MS);
-    console.warn(`[tunnel] sidecar exited \u2014 restarting in ${Math.round(delay2 / 1e3)}s`);
-    this.restartTimer = setTimeout(() => {
-      this.restartTimer = null;
-      this.spawnSidecar();
-    }, delay2);
+    this.sidecar.start();
   }
   // Reverse-shell map key: a build mirrored onto several runners has one shell per machine.
   static shellKey(build, machine) {
     return `${build}\0${machine}`;
   }
-  // Sidecar emits newline-delimited JSON events on stdout; `ready` carries the tunnel node, and
-  // shell-opened/shell-output/shell-closed carry reverse-shell traffic for a (build, machine).
-  onStdout = createNdjsonParser((evt) => {
+  onEvent(evt) {
     if (evt.event === "ready" && evt.tailnetAddr && evt.sshHostKey) {
       this.node = { tailnetAddr: evt.tailnetAddr, sshHostKey: evt.sshHostKey };
-      this.restartDelayMs = RESTART_MIN_MS;
+      this.sidecar.resetBackoff();
       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 s = this.shellState(_TunnelServer.shellKey(evt.build, evt.machine ?? ""));
       if (evt.event === "shell-opened") {
+        s.connected = true;
         s.closed = false;
+        s.gen++;
       } else if (evt.event === "shell-output") {
+        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 {
+        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"}`);
     }
-  });
+  }
   // --- Reverse shell (agent → user's machine via the sync client) -----------------------------
   // Whether reverse-shell control can be sent at all (sidecar up with a writable stdin). The tool
   // checks this to fail fast instead of writing into the void.
   shellAvailable() {
-    return Boolean(this.proc && !this.proc.killed && this.proc.stdin && !this.proc.stdin.destroyed);
-  }
-  writeControl(msg) {
-    const stdin = this.proc?.stdin;
-    if (!stdin || stdin.destroyed) return false;
-    try {
-      stdin.write(JSON.stringify(msg) + "\n");
-      return true;
-    } catch {
-      return false;
-    }
+    return this.sidecar.alive();
   }
   // Send keystrokes/command text to a (build, machine) shell. data is UTF-8 text (may include control
   // bytes like \x03 for Ctrl-C); it's base64-framed on the wire.
   shellSendInput(build, machine, data) {
-    return this.writeControl({ cmd: "shell-input", build, machine, data: Buffer.from(data, "utf8").toString("base64") });
-  }
-  shellClosed(build, machine) {
-    return this.shells.get(_TunnelServer.shellKey(build, machine))?.closed ?? false;
+    return this.sidecar.write({ cmd: "shell-input", build, machine, data: Buffer.from(data, "utf8").toString("base64") });
+  }
+  // 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 s = this.shellState(_TunnelServer.shellKey(build, machine));
@@ -16834,41 +16891,38 @@ var TunnelServer = class _TunnelServer {
   }
   // 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; the closed
-  // marker is cleared too so the next session for this key starts fresh.
+  // 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 s = this.shells.get(key);
+    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;
-    if (s.listeners.size === 0) this.shells.delete(key);
     return out;
   }
   shellState(key) {
     let s = this.shells.get(key);
     if (!s) {
-      s = { buffer: EMPTY_BUFFER, closed: false, listeners: /* @__PURE__ */ new Set() };
+      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 states = [...this.shells.values()];
-    this.shells.clear();
-    for (const s of states) for (const l of [...s.listeners]) l.onClosed();
+    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.sidecar.stop();
     this.node = null;
     this.closeAllShells();
   }
@@ -16928,6 +16982,7 @@ async function startCommand(args2) {
   const { flags, bools } = parseFlags(args2, { f: "foreground" });
   if (bools.supervisor) return runSupervisor(args2);
   if (bools.foreground) {
+    installTimestampedLogging();
     const { config: config2, serverUrl } = await ensureEnrolled(flags);
     return runWorker(config2, serverUrl);
   }
@@ -17049,16 +17104,25 @@ 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;
+    syncManager.onHealthChanged = () => client.pokePresence();
   };
   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")) {
@@ -17396,16 +17460,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}`);
@@ -17413,8 +17477,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 } };
@@ -17751,6 +17815,32 @@ async function logoutCommand() {
   console.log("[tds] Run 'tds start' to enroll again.");
 }
 
+// src/lib/version.ts
+var import_fs6 = require("fs");
+var import_path2 = require("path");
+function getVersion() {
+  let dir = __dirname;
+  for (let i = 0; i < 6; i++) {
+    const p = (0, import_path2.join)(dir, "package.json");
+    if ((0, import_fs6.existsSync)(p)) {
+      try {
+        const pkg = JSON.parse((0, import_fs6.readFileSync)(p, "utf-8"));
+        if (pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+    const parent = (0, import_path2.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "unknown";
+}
+
+// src/commands/version.ts
+async function versionCommand() {
+  console.log(`tds ${getVersion()}`);
+}
+
 // src/index.ts
 var COMMANDS = {
   start: {
@@ -17820,6 +17910,13 @@ Stop the background daemon (if running), then clear ~/.tds/machine.json so the n
     help: `Usage: tds status
 
 Show this machine's registration and current status.`
+  },
+  version: {
+    run: () => versionCommand(),
+    summary: "Show the tds CLI version",
+    help: `Usage: tds version
+
+Print the installed tds CLI version.`
   },
   provider: {
     run: providerCommand,
@@ -17838,6 +17935,10 @@ Subcommands:
 var args = process.argv.slice(2);
 var cmd = args[0];
 var rest = args.slice(1);
+if (cmd === "--version" || cmd === "-v") {
+  console.log(`tds ${getVersion()}`);
+  process.exit(0);
+}
 if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
   const topic = cmd === "help" ? rest[0] : void 0;
   if (topic && COMMANDS[topic]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@todos-dev/cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "bin": {
     "tds": "dist/index.js"
   },
@@ -27,12 +27,12 @@
     "@tds/types": "0.1.0"
   },
   "optionalDependencies": {
-    "@todos-dev/cli-darwin-arm64": "0.1.2",
-    "@todos-dev/cli-darwin-x64": "0.1.2",
-    "@todos-dev/cli-linux-x64": "0.1.2",
-    "@todos-dev/cli-linux-arm64": "0.1.2",
-    "@todos-dev/cli-win32-x64": "0.1.2",
-    "@todos-dev/cli-win32-arm64": "0.1.2"
+    "@todos-dev/cli-darwin-arm64": "0.1.4",
+    "@todos-dev/cli-darwin-x64": "0.1.4",
+    "@todos-dev/cli-linux-x64": "0.1.4",
+    "@todos-dev/cli-linux-arm64": "0.1.4",
+    "@todos-dev/cli-win32-x64": "0.1.4",
+    "@todos-dev/cli-win32-arm64": "0.1.4"
   },
   "scripts": {
     "dev": "tsx watch src/index.ts",