@todos-dev/cli 0.1.3 → 0.1.5

package/dist/index.js

@@ -484,6 +484,11 @@ function text(s, details) {
 // src/lib/todoTools.ts
 var REQUEST_TIMEOUT_MS = 1e4;
 var LIST_CAP = 8e3;
+function toolScope(step) {
+  if (step.workspace?.projectId) return { kind: "project", projectId: step.workspace.projectId };
+  if (step.chiefId) return { kind: "account", chiefId: step.chiefId };
+  return null;
+}
 async function request(serverUrl, method, path, token, body) {
   const headers = { "Content-Type": "application/json" };
   if (token) headers["Authorization"] = `Bearer ${token}`;
@@ -511,60 +516,80 @@ function makeTodoTools(serverUrl, token, step) {
   ];
 }
 function makeListTodosTool(serverUrl, token, step) {
-  const projectId = step.workspace?.projectId;
+  const scope = toolScope(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. 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).`,
+    description: scope?.kind === "account" ? `List the todo boards of every project across the user's teams, grouped by project. Each project header carries its projectId (required by create_todo); each todo renders as "#<seq> [<phase>] <title> (id: <id>)".` : `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, 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(", ")}
+      if (scope?.kind === "project") {
+        const { projectId } = scope;
+        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)" : "";
-        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 = header + lines.join("\n");
-      if (out.length > LIST_CAP) out = out.slice(0, LIST_CAP) + "\n\u2026(truncated)";
-      return text2(out);
+        const lines = todos.map((t) => {
+          const mine = t.createdBy === step.agent.agentId ? " (yours)" : "";
+          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 = header + lines.join("\n");
+        if (out.length > LIST_CAP) out = out.slice(0, LIST_CAP) + "\n\u2026(truncated)";
+        return text2(out);
+      }
+      if (scope?.kind === "account") {
+        const reply = await request(serverUrl, "GET", `/api/machine/chief/todos?chiefId=${encodeURIComponent(scope.chiefId)}`, token);
+        if (!reply.ok) return text2(errorText(reply, "Failed to list todos"));
+        const projects = reply.body?.projects ?? [];
+        if (!projects.length) return text2("No projects in your teams yet.");
+        const blocks = projects.map((p) => {
+          const lines = p.todos.length ? p.todos.map((t) => `#${t.seqNum} [${t.phase}] ${t.title} (id: ${t.id})`).join("\n") : "(no todos)";
+          return `## ${p.name} (projectId: ${p.id})
+${lines}`;
+        });
+        let out = blocks.join("\n\n");
+        if (out.length > LIST_CAP) out = out.slice(0, LIST_CAP) + "\n\u2026(truncated)";
+        return text2(out);
+      }
+      return text2("No project context for this turn \u2014 todos are unavailable.");
     }
   };
 }
 function makeCreateTodoTool(serverUrl, token, step) {
-  const projectId = step.workspace?.projectId;
+  const scope = toolScope(step);
+  const accountScope = scope?.kind === "account";
   return {
     name: "create_todo",
     label: "Create Todo",
-    description: "Create a follow-up todo for work you discovered but that is out of scope for the current task (e.g. a refactor, a separate bug, a next step). The new todo is added to the project backlog and does NOT run automatically \u2014 the user decides when to start it. Use a clear, actionable title and put the context/acceptance criteria in spec.",
+    description: accountScope ? "Create a todo in one of the user's projects (projectId comes from list_todos's project headers). The new todo lands in that project's backlog and does NOT run automatically \u2014 propose it with propose_builds when it should run. Use a clear, actionable title and put the objective, boundaries, and acceptance criteria in spec." : "Create a follow-up todo for work you discovered but that is out of scope for the current task (e.g. a refactor, a separate bug, a next step). The new todo is added to the project backlog and does NOT run automatically \u2014 the user decides when to start it. Use a clear, actionable title and put the context/acceptance criteria in spec.",
     parameters: {
       type: "object",
       properties: {
-        title: { type: "string", description: "Short, actionable title for the follow-up work." },
+        ...accountScope ? { projectId: { type: "string", description: "Target project id (from list_todos)." } } : {},
+        title: { type: "string", description: "Short, actionable title for the work." },
         spec: { type: "string", description: "Details: what to do, why, and any acceptance criteria. Optional but recommended." }
       },
-      required: ["title"],
+      required: accountScope ? ["projectId", "title"] : ["title"],
       additionalProperties: false
     },
     async execute(_id, params) {
-      if (!projectId) return text2("No project context for this turn \u2014 cannot create a todo.");
       const p = params ?? {};
+      const projectId = scope?.kind === "project" ? scope.projectId : p.projectId;
+      if (!scope || !projectId) return text2(accountScope ? "A projectId is required (find it with list_todos)." : "No project context for this turn \u2014 cannot create a todo.");
       if (!p.title?.trim()) return text2("A title is required to create a todo.");
       const reply = await request(serverUrl, "POST", `/api/projects/${projectId}/todos`, token, {
         title: p.title,
         spec: p.spec ?? "",
-        buildId: step.conversationId
+        buildId: scope.kind === "account" ? scope.chiefId : step.conversationId
       });
       if (!reply.ok) return text2(errorText(reply, "Failed to create todo"));
       const t = reply.body;
@@ -573,10 +598,11 @@ function makeCreateTodoTool(serverUrl, token, step) {
   };
 }
 function makeUpdateTodoTool(serverUrl, token, step) {
+  const scope = toolScope(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 (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.`,
+    description: scope?.kind === "account" ? "Update a todo's title or spec \u2014 use this to groom a todo before proposing it: make the spec state the objective, boundaries, and acceptance criteria. You cannot change a todo's phase, assignment, or start a build." : `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: {
@@ -591,7 +617,7 @@ function makeUpdateTodoTool(serverUrl, token, step) {
     async execute(_id, params) {
       const p = params ?? {};
       if (!p.id) return text2("A todo id is required (find it with list_todos).");
-      const patch = { buildId: step.conversationId };
+      const patch = { buildId: scope?.kind === "account" ? scope.chiefId : step.conversationId };
       if (p.title !== void 0) patch.title = p.title;
       if (p.spec !== void 0) patch.spec = p.spec;
       if (p.tagIds !== void 0) patch.tagIds = p.tagIds;
@@ -603,6 +629,126 @@ function makeUpdateTodoTool(serverUrl, token, step) {
   };
 }
 
+// src/lib/chiefTools.ts
+function makeChiefTools(serverUrl, token, step) {
+  return [
+    makeProposeBuildsTool(serverUrl, token, step),
+    makeRunBuildsTool(serverUrl, token, step),
+    makeUpdateMemoryTool(serverUrl, token, step)
+  ];
+}
+var DISPATCH_ITEMS_SCHEMA = {
+  type: "array",
+  minItems: 1,
+  items: {
+    type: "object",
+    properties: {
+      todoId: { type: "string", description: "The todo to run (id from list_todos)." },
+      withPlan: { type: "boolean", description: "Start with a plan step the user confirms before implementation. Default false." },
+      agentId: { type: "string", description: "Suggested agent (from the available-agents list). Omit to use the todo's own assignment." },
+      thinkingLevel: { type: "string", description: "Suggested thinking level for the agent (only with agentId)." },
+      reason: { type: "string", description: "One line on why this todo, this agent, now." }
+    },
+    required: ["todoId"],
+    additionalProperties: false
+  }
+};
+function itemsToBody(items) {
+  return items.map((i) => ({
+    todoId: i.todoId,
+    ...i.withPlan !== void 0 ? { withPlan: i.withPlan } : {},
+    ...i.agentId ? { agent: { agentId: i.agentId, ...i.thinkingLevel ? { thinkingLevel: i.thinkingLevel } : {} } } : {},
+    ...i.reason ? { reason: i.reason } : {}
+  }));
+}
+function makeProposeBuildsTool(serverUrl, token, step) {
+  const chiefId = step.chiefId;
+  return {
+    name: "propose_builds",
+    label: "Propose Builds",
+    description: "Propose which todos to run next. This does NOT start anything \u2014 it creates a proposal card the user reviews, adjusts, and runs. Use this for work YOU are initiating; when the user has explicitly asked to run something, use run_builds instead. Pick the agent (agentId from the available-agents list) and thinking level per item to match the work; set withPlan for tasks that deserve a reviewed plan first. Groom each todo (update_todo: objective, boundaries, acceptance criteria) BEFORE proposing it. On success, reference the returned doc id in your reply as [Run N todos](doc:<id>) so the user sees the card.",
+    parameters: {
+      type: "object",
+      properties: {
+        items: DISPATCH_ITEMS_SCHEMA,
+        summary: { type: "string", description: "One-line summary of the proposal as a whole (optional)." }
+      },
+      required: ["items"],
+      additionalProperties: false
+    },
+    async execute(_id, params) {
+      if (!chiefId) return text2("propose_builds is only available in the chief conversation.");
+      const p = params ?? {};
+      const items = (p.items ?? []).filter((i) => i?.todoId);
+      if (!items.length) return text2("At least one item with a todoId is required.");
+      const reply = await request(serverUrl, "POST", "/api/machine/chief/proposals", token, {
+        chiefId,
+        items: itemsToBody(items),
+        ...p.summary ? { summary: p.summary } : {}
+      });
+      if (!reply.ok) return text2(errorText(reply, "Failed to create the proposal"));
+      const docId = reply.body?.docId;
+      return text2(`Created a proposal with ${items.length} item(s). Reference it in your reply as [Run ${items.length} todo${items.length > 1 ? "s" : ""}](doc:${docId}) so the user sees the proposal card.`);
+    }
+  };
+}
+function makeRunBuildsTool(serverUrl, token, step) {
+  const chiefId = step.chiefId;
+  return {
+    name: "run_builds",
+    label: "Run Builds",
+    description: "Start builds for todos IMMEDIATELY \u2014 no confirmation card. Use this ONLY when the user has explicitly asked for the work to run in this conversation (their message is the approval); for work you are initiating yourself, use propose_builds instead. Same item shape as propose_builds: pick agent/thinkingLevel per item, withPlan for tasks needing a reviewed plan. Groom each todo before running it.",
+    parameters: {
+      type: "object",
+      properties: {
+        items: DISPATCH_ITEMS_SCHEMA
+      },
+      required: ["items"],
+      additionalProperties: false
+    },
+    async execute(_id, params) {
+      if (!chiefId) return text2("run_builds is only available in the chief conversation.");
+      const p = params ?? {};
+      const items = (p.items ?? []).filter((i) => i?.todoId);
+      if (!items.length) return text2("At least one item with a todoId is required.");
+      const reply = await request(serverUrl, "POST", "/api/machine/chief/builds", token, {
+        chiefId,
+        items: itemsToBody(items)
+      });
+      if (!reply.ok) return text2(errorText(reply, "Failed to start builds"));
+      const started = reply.body?.started ?? [];
+      const skipped = items.length - started.length;
+      return text2(
+        `Started ${started.length} build(s): ${started.map((s) => `#${s.seqNum}`).join(", ")}.` + (skipped > 0 ? ` ${skipped} item(s) were skipped (phase changed or no resolvable agent).` : "") + " Tell the user what is now running and with which agents."
+      );
+    }
+  };
+}
+function makeUpdateMemoryTool(serverUrl, token, step) {
+  const chiefId = step.chiefId;
+  return {
+    name: "update_memory",
+    label: "Update Memory",
+    description: "Rewrite your persistent memory \u2014 the notes injected into every future turn, surviving session resets. FULL REPLACEMENT: send the complete new text, not a diff; prune stale entries to stay under the size cap. Save immediately when you learn a durable routing preference, a user preference, or a lesson \u2014 do not wait. Every update is kept as a version the user can restore.",
+    parameters: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "The complete new memory text (replaces the old entirely)." }
+      },
+      required: ["content"],
+      additionalProperties: false
+    },
+    async execute(_id, params) {
+      if (!chiefId) return text2("update_memory is only available in the chief conversation.");
+      const p = params ?? {};
+      if (!p.content?.trim()) return text2("Memory content is required (full replacement text).");
+      const reply = await request(serverUrl, "POST", "/api/machine/chief/memory", token, { chiefId, content: p.content });
+      if (!reply.ok) return text2(errorText(reply, "Failed to update memory"));
+      return text2("Memory updated. It will be injected into your future turns.");
+    }
+  };
+}
+
 // src/lib/sessionStore.ts
 var import_node_fs3 = require("node:fs");
 var import_promises = require("node:fs/promises");
@@ -1212,7 +1358,8 @@ async function executeStep(step, serverUrl, token, tunnel) {
     const skills = await materializeSkills(step.skills, agentDir);
     const extraCustomTools = [
       makeClientShellTool(tunnel, conversationId, runnersRef),
-      ...makeTodoTools(serverUrl, token, step)
+      ...makeTodoTools(serverUrl, token, step),
+      ...makeChiefTools(serverUrl, token, step)
     ];
     const session = await createSession(sdk, {
       authStorage,
@@ -1367,6 +1514,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;
@@ -1431,6 +1590,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;
@@ -14173,14 +14333,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, {
@@ -16018,7 +16178,8 @@ var STEP_DEF = {
   implement_revision: { track: "implement", sink: "chat", phase: { busy: "building", rest: "review", notify: "build_review" } },
   merge: { track: "implement", sink: "chat", phase: { busy: "building", rest: "review", notify: "build_review" } },
   plan_review: { track: "plan", sink: "review" },
-  implement_review: { track: "implement", sink: "review" }
+  implement_review: { track: "implement", sink: "review" },
+  chief: { sink: "chief" }
 };
 var isReviewStep = (k) => STEP_DEF[k].sink === "review";
 var REVIEW_STEP_KINDS = Object.keys(STEP_DEF).filter(isReviewStep);
@@ -16095,6 +16256,33 @@ var UpdateTodoRequestSchema = external_exports.object({
 });
 var MachineCreateTodoRequestSchema = CreateTodoRequestSchema.extend({ buildId: external_exports.string() });
 var MachineUpdateTodoRequestSchema = UpdateTodoRequestSchema.omit({ assignment: true }).extend({ buildId: external_exports.string() });
+var UpdateChiefRequestSchema = external_exports.object({
+  agent: AgentEntrySchema.nullable().optional(),
+  charter: external_exports.string().optional()
+});
+var ChiefStepRequestSchema = external_exports.object({
+  content: external_exports.string().trim().min(1)
+});
+var DispatchItemSchema = external_exports.object({
+  todoId: external_exports.string().min(1),
+  withPlan: external_exports.boolean().optional(),
+  agent: AgentEntrySchema.optional(),
+  reason: external_exports.string().optional()
+});
+var MAX_DISPATCH_ITEMS = 20;
+var MachineProposeBuildsRequestSchema = external_exports.object({
+  chiefId: external_exports.string().min(1),
+  items: external_exports.array(DispatchItemSchema).min(1).max(MAX_DISPATCH_ITEMS),
+  summary: external_exports.string().optional()
+});
+var MachineRunBuildsRequestSchema = external_exports.object({
+  chiefId: external_exports.string().min(1),
+  items: external_exports.array(DispatchItemSchema).min(1).max(MAX_DISPATCH_ITEMS)
+});
+var MachineUpdateMemoryRequestSchema = external_exports.object({
+  chiefId: external_exports.string().min(1),
+  content: external_exports.string().min(1)
+});
 var TriggerBuildRequestSchema = external_exports.object({
   todoIds: external_exports.array(external_exports.string()).min(1),
   // One-time assignment override; falls back to todo.assignment. Server enriches model.
@@ -16183,6 +16371,7 @@ var PollClient = class {
   runningTasks = /* @__PURE__ */ new Map();
   presenceTimer = null;
   gcTimer = null;
+  pokeTimer = null;
   lastSentTunnelKey;
   revoked = false;
   maxConcurrentTasks = null;
@@ -16223,6 +16412,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;
@@ -16257,6 +16456,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.
@@ -16413,10 +16616,12 @@ function sleep(ms, signal) {
 }
 
 // src/SyncManager.ts
-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/sidecar.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");
@@ -16482,31 +16687,24 @@ function createNdjsonParser(onEvent) {
   };
 }
 
-// src/SyncManager.ts
+// src/lib/sidecar.ts
 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 {
-  // by mountId
-  constructor(serverUrl, token, machineId) {
-    this.serverUrl = serverUrl;
-    this.token = token;
-    this.machineId = machineId;
+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;
-  desired = [];
-  health = /* @__PURE__ */ new Map();
+  parse;
   start() {
     this.stopped = false;
-    console.log(`[machine] runner: managing worktree mirrors (machineId=${this.machineId})`);
-    this.spawnSidecar();
+    this.spawn();
   }
   stop() {
     this.stopped = true;
@@ -16517,6 +16715,88 @@ var SyncManager = class {
     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
+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 {
+  constructor(serverUrl, token, machineId) {
+    this.machineId = machineId;
+    this.sidecar = new Sidecar(
+      ["mirror", "--server", serverUrl, "--token", token, "--machine", machineId],
+      "runner",
+      (e) => this.onEvent(e)
+    );
+  }
+  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() {
+    console.log(`[machine] runner: managing worktree mirrors (machineId=${this.machineId})`);
+    this.sidecar.start();
+  }
+  stop() {
+    this.sidecar.stop();
+  }
   // 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) {
@@ -16545,64 +16825,36 @@ var SyncManager = class {
       };
     });
   }
-  spawnSidecar() {
-    try {
-      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 {
-      console.warn("[machine] runner: tds-tunnel not available \u2014 mirroring disabled");
-      return;
-    }
-    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.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(`[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) => {
+  onEvent(e) {
     if (e.event === "up") {
-      this.restartDelayMs = RESTART_MIN_MS;
+      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 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"}`);
+        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() {
-    const stdin = this.proc?.stdin;
-    if (!stdin || stdin.destroyed) return;
-    try {
-      stdin.write(JSON.stringify({ cmd: "mounts", mounts: this.desired }) + "\n");
-    } catch {
-    }
+    this.sidecar.write({ cmd: "mounts", mounts: this.desired });
   }
 };
 
@@ -16714,26 +16966,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_MS2 = 1e3;
-var RESTART_MAX_MS2 = 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_MS2;
+  // 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) {
@@ -16741,56 +16997,16 @@ 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_MS2);
-    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_MS2;
+      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) {
@@ -16814,27 +17030,17 @@ var TunnelServer = class _TunnelServer {
     } 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") });
+    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
@@ -16891,13 +17097,7 @@ var TunnelServer = class _TunnelServer {
     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();
   }
@@ -16957,6 +17157,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);
   }
@@ -17089,6 +17290,7 @@ async function runWorker(config2, serverUrl) {
     syncManager.start();
     syncManager.setMounts(lastMounts);
     client.getMountSync = () => syncManager?.status() ?? null;
+    syncManager.onHealthChanged = () => client.pokePresence();
   };
   const disableRunner = () => {
     if (!syncManager) return;
@@ -17788,6 +17990,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: {
@@ -17857,6 +18085,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,
@@ -17875,6 +18110,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.3",
+  "version": "0.1.5",
   "bin": {
     "tds": "dist/index.js"
   },
@@ -27,12 +27,12 @@
     "@tds/types": "0.1.0"
   },
   "optionalDependencies": {
-    "@todos-dev/cli-darwin-arm64": "0.1.3",
-    "@todos-dev/cli-darwin-x64": "0.1.3",
-    "@todos-dev/cli-linux-x64": "0.1.3",
-    "@todos-dev/cli-linux-arm64": "0.1.3",
-    "@todos-dev/cli-win32-x64": "0.1.3",
-    "@todos-dev/cli-win32-arm64": "0.1.3"
+    "@todos-dev/cli-darwin-arm64": "0.1.5",
+    "@todos-dev/cli-darwin-x64": "0.1.5",
+    "@todos-dev/cli-linux-x64": "0.1.5",
+    "@todos-dev/cli-linux-arm64": "0.1.5",
+    "@todos-dev/cli-win32-x64": "0.1.5",
+    "@todos-dev/cli-win32-arm64": "0.1.5"
   },
   "scripts": {
     "dev": "tsx watch src/index.ts",