@todos-dev/cli 0.1.1 → 0.1.2

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;
@@ -689,14 +673,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 +848,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,21 +872,31 @@ 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 {};
   }
 }
+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) {
   let active = true;
   let inFlight = false;
@@ -926,7 +917,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 +932,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 +981,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 +1006,6 @@ function attachStreamingSession(session, label, postToken) {
   const dispose = () => {
     if (disposed) return;
     disposed = true;
-    clearInterval(flushTimer);
     unsub();
     try {
       session.dispose();
@@ -1033,16 +1014,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 {
@@ -1166,18 +1148,19 @@ 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 stopHeartbeat = startHeartbeat(serverUrl, stepId, agentId, stopTurn, token);
+  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,23 +1168,22 @@ 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}` });
+        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, 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}`);
@@ -1226,62 +1208,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 +1231,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 +1248,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 +1279,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 +1299,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 +15998,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 +16009,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 +16051,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(),
@@ -16369,8 +16299,8 @@ ${node.sshHostKey}` : null };
         if (Array.isArray(data?.roles)) {
           this.setRoles(data.roles.filter((r) => r === "builder" || r === "runner"));
         }
+        this.lastSentTunnelKey = key;
       }
-      this.lastSentTunnelKey = key;
     } catch {
     }
   }
@@ -16397,9 +16327,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;
@@ -16500,6 +16428,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");
@@ -16533,7 +16462,7 @@ function spawnMirror(opts) {
     opts.serverUrl,
     "--token",
     opts.token,
-    "--conversation",
+    "--build",
     opts.buildId,
     "--dest",
     opts.dest,
@@ -16619,6 +16548,7 @@ var SyncManager = class {
     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);
@@ -16776,6 +16706,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_MS = 1e3;
+var RESTART_MAX_MS = 6e4;
+var EMPTY_BUFFER = Buffer.alloc(0);
 var TunnelServer = class _TunnelServer {
   constructor(serverUrl, token) {
     this.serverUrl = serverUrl;
@@ -16784,14 +16717,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_MS;
+  // 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 +16731,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 +16755,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_MS);
+    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 +16780,22 @@ 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_MS;
       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.closed = false;
       } 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.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.closed = true;
+        for (const l of [...s.listeners]) l.onClosed();
       }
     } else if (evt.event === "error") {
       console.warn(`[tunnel] ${evt.message ?? "error"}`);
@@ -16873,51 +16823,50 @@ var TunnelServer = class _TunnelServer {
     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));
+    return this.shells.get(_TunnelServer.shellKey(build, machine))?.closed ?? false;
   }
   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.
   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(key);
+    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() };
+      this.shells.set(key, s);
+    }
+    return s;
   }
   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();
+    const states = [...this.shells.values()];
+    this.shells.clear();
+    for (const s of states) 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 +16876,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 +16884,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 +16925,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);
@@ -17182,13 +17128,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 +17191,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 +17212,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") {
@@ -17556,7 +17502,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 +17649,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 +17754,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 +17779,7 @@ Options:
   --server <url>    Override the server URL`
   },
   stop: {
+    run: () => stopCommand(),
     summary: "Stop the background machine",
     help: `Usage: tds stop
 
@@ -17838,6 +17787,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 +17796,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 +17806,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 +17815,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 +17851,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@todos-dev/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "bin": {
     "tds": "dist/index.js"
   },
@@ -11,8 +11,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "0.80.2",
-    "@earendil-works/pi-coding-agent": "0.80.2",
+    "@earendil-works/pi-ai": "0.80.3",
+    "@earendil-works/pi-coding-agent": "0.80.3",
     "@inquirer/core": "^10",
     "@inquirer/prompts": "^7",
     "@inquirer/search": "^3",
@@ -27,12 +27,12 @@
     "@tds/types": "0.1.0"
   },
   "optionalDependencies": {
-    "@todos-dev/cli-darwin-arm64": "0.1.1",
-    "@todos-dev/cli-darwin-x64": "0.1.1",
-    "@todos-dev/cli-linux-x64": "0.1.1",
-    "@todos-dev/cli-linux-arm64": "0.1.1",
-    "@todos-dev/cli-win32-x64": "0.1.1",
-    "@todos-dev/cli-win32-arm64": "0.1.1"
+    "@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"
   },
   "scripts": {
     "dev": "tsx watch src/index.ts",
@@ -41,6 +41,6 @@
     "typecheck": "tsc --noEmit",
     "release": "node ../../scripts/release-cli.mjs",
     "start": "node dist/index.js",
-    "reinstall": "rm -f todos-dev-cli-*.tgz && pnpm pack && npm i -g \"$PWD/$(ls todos-dev-cli-*.tgz)\" && rm -f todos-dev-cli-*.tgz"
+    "reinstall": "rm -f todos-dev-cli-*.tgz && TDS_BUNDLE_TUNNEL=1 pnpm pack && npm i -g \"$PWD/$(ls todos-dev-cli-*.tgz)\" && rm -f todos-dev-cli-*.tgz"
   }
 }