@synkro-sh/cli 1.10.6 → 1.10.8

package/dist/bootstrap.js

@@ -147,7 +147,7 @@ function getIdentity() {
   if (cached2) return cached2;
   let cliVersion2 = "0.0.0";
   try {
-    cliVersion2 = "1.10.6";
+    cliVersion2 = "1.10.8";
   } catch {
   }
   const creds = loadCredentialsIdentity();
@@ -2351,7 +2351,7 @@ function buildCodexHookTrustEdits(hooks) {
   return [...edits.values()];
 }
 function queryCodexHookTrust(codexBinary = "codex", cwd = process.cwd(), autoTrust = false) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     let settled = false;
     let stdout = "";
     let pending = "";
@@ -2369,7 +2369,7 @@ function queryCodexHookTrust(codexBinary = "codex", cwd = process.cwd(), autoTru
         child.kill();
       } catch {
       }
-      resolve7(summary);
+      resolve8(summary);
     };
     const timer = setTimeout(() => finish(null), 1e4);
     try {
@@ -5181,7 +5181,7 @@ function createCallbackServer() {
     "Access-Control-Allow-Headers": "Content-Type",
     "Vary": "Origin"
   };
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const server = createServer((req, res) => {
       if (req.method === "OPTIONS") {
         const origin = req.headers.origin;
@@ -5270,7 +5270,7 @@ function createCallbackServer() {
         res.end(JSON.stringify({ ok: true }));
         setTimeout(() => {
           server.close();
-          resolve7(authData);
+          resolve8(authData);
         }, 200);
       });
       req.on("error", (e) => {
@@ -5606,7 +5606,7 @@ function detectSubdirRepos() {
   }
 }
 function ask(rl, question) {
-  return new Promise((resolve7) => rl.question(question, resolve7));
+  return new Promise((resolve8) => rl.question(question, resolve8));
 }
 async function linkRepo(repo, linkedNames) {
   try {
@@ -5845,7 +5845,7 @@ async function runClaudeDesktopTap(opts = {}) {
   writeFileSync12(join13(sessionDir, "mcp_patch.py"), MCP_PATCH_PY, "utf-8");
   const runnerPath = join13(sessionDir, "run.sh");
   writeFileSync12(runnerPath, buildRunner(sessionDir), { mode: 493 });
-  await new Promise((resolve7) => {
+  await new Promise((resolve8) => {
     const child = spawn3("bash", [runnerPath], {
       stdio: "inherit",
       env: { ...process.env, SYNKRO_CAPTURE_URL: CAPTURE_URL, SYNKRO_SCAN_URL: SCAN_URL, SYNKRO_SCAN_TURN_URL: SCAN_TURN_URL, SYNKRO_DLP_POLICY_URL: DLP_POLICY_URL, SYNKRO_TURN_VERDICTS_URL: TURN_VERDICTS_URL, SYNKRO_TURN_VERDICT_URL: TURN_VERDICT_URL, SYNKRO_MCP_EVENT_URL: MCP_EVENT_URL, SYNKRO_TAP_TOKEN: token, SYNKRO_TAP_TOKEN_FILE: JWT_PATH, SYNKRO_CD_BACKFILL: opts.backfill ? "1" : "" }
@@ -5861,7 +5861,7 @@ async function runClaudeDesktopTap(opts = {}) {
     child.on("exit", () => {
       process.off("SIGINT", forward);
       process.off("SIGTERM", forward);
-      resolve7();
+      resolve8();
     });
   });
 }
@@ -7934,7 +7934,7 @@ var init_dockerInstall = __esm({
     HOST_PGLITE_PORT = parseInt(process.env.SYNKRO_HOST_PGLITE_PORT || "15433", 10);
     CONTAINER_NAME = resolveContainerName();
     defaultImageVersion = () => {
-      if (true) return "1.10.6";
+      if (true) return "1.10.8";
       try {
         const pkg = JSON.parse(readFileSync17(new URL("../../package.json", import.meta.url), "utf8"));
         if (pkg.version) return pkg.version;
@@ -7966,7 +7966,7 @@ function captureClaudeSetupToken() {
   const bin = "script";
   const args2 = isMac ? ["-q", tmpFile, "claude", "setup-token"] : ["-qec", "claude setup-token", tmpFile];
   const OAUTH_HINT = 'The browser approval did not return a token. This usually means claude.ai rejected the OAuth request (its "Authorization failed \u2014 Unsupported media type" page), most often because a browser extension (Grammarly, ad/script blockers, AI-assistant toolbars) stripped the request headers, or you approved on the wrong Claude account. Fix: retry in a clean incognito window with extensions disabled, and approve on the Claude account you want the cloud workers to use.';
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const proc = nodeSpawn(bin, args2, {
       stdio: "inherit",
       env: { ...process.env, FORCE_COLOR: "3", COLORTERM: "truecolor", TERM: "xterm-256color" }
@@ -8033,7 +8033,7 @@ function captureClaudeSetupToken() {
         reject(new Error(`Captured no setup token from claude setup-token output. ${reason}`));
         return;
       }
-      resolve7(token);
+      resolve8(token);
     });
   });
 }
@@ -8059,13 +8059,13 @@ function findCodexBinary() {
 function runCodexLogin(codexBin, codexHome) {
   mkdirSync13(codexHome, { recursive: true, mode: 448 });
   writeFileSync15(join17(codexHome, "config.toml"), 'cli_auth_credentials_store = "file"\n', { mode: 384 });
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const proc = nodeSpawn2(codexBin, ["login"], {
       stdio: "inherit",
       env: { ...process.env, CODEX_HOME: codexHome }
     });
     proc.on("error", (err) => reject(new Error(`failed to spawn codex login: ${err.message}`)));
-    proc.on("close", (code) => code === 0 ? resolve7() : reject(new Error(`codex login exited with code ${code}`)));
+    proc.on("close", (code) => code === 0 ? resolve8() : reject(new Error(`codex login exited with code ${code}`)));
   });
 }
 async function setupCodexCloud(gatewayUrl, bearerToken, onStatus) {
@@ -8767,20 +8767,20 @@ async function promptAgentSelection(detected) {
   detected.forEach((a, i) => console.log(`  ${i + 1}. ${a.name}`));
   console.log(`  ${detected.length + 1}. Both / all (default)`);
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  const ask3 = () => new Promise((resolve7) => {
+  const ask3 = () => new Promise((resolve8) => {
     rl.question(`Pick [1-${detected.length + 1}] (default: all): `, (answer) => {
       const t = answer.trim().toLowerCase();
       if (t === "" || t === String(detected.length + 1) || t === "both" || t === "all") {
         rl.close();
-        return resolve7(detected);
+        return resolve8(detected);
       }
       const n = parseInt(t, 10);
       if (Number.isInteger(n) && n >= 1 && n <= detected.length) {
         rl.close();
-        return resolve7([detected[n - 1]]);
+        return resolve8([detected[n - 1]]);
       }
       console.log("Invalid choice. Try again.");
-      resolve7(ask3());
+      resolve8(ask3());
     });
   });
   return ask3();
@@ -8803,12 +8803,12 @@ async function promptCursorApiKey(opts) {
     return;
   }
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  const key = await new Promise((resolve7) => {
+  const key = await new Promise((resolve8) => {
     rl.question(
       "Cursor grading needs a Cursor API key (cursor.com \u2192 Settings \u2192 API Keys).\nPaste it now, or press Enter to skip (Cursor workers stay idle until set): ",
       (answer) => {
         rl.close();
-        resolve7(answer.trim());
+        resolve8(answer.trim());
       }
     );
   });
@@ -8823,7 +8823,7 @@ async function promptDeployLocation(current = "local") {
   if (!process.stdin.isTTY) return current;
   const other = current === "cloud" ? "local" : "cloud";
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     rl.question(
       `Where should Synkro run?
   local \u2014 a grading container on this machine (Docker)
@@ -8832,7 +8832,7 @@ Each worker uses the account credentials you authorize. Choose [${current}] / ${
       (answer) => {
         rl.close();
         const a = answer.trim().toLowerCase();
-        resolve7(a === "cloud" ? "cloud" : a === "local" ? "local" : current);
+        resolve8(a === "cloud" ? "cloud" : a === "local" ? "local" : current);
       }
     );
   });
@@ -8994,7 +8994,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle2(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle2(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle2(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle2("1.10.6")}`
+    `SYNKRO_VERSION=${shellQuoteSingle2("1.10.8")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle2(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle2(safeUserId)}`);
@@ -9741,7 +9741,7 @@ async function installCommand(opts = {}) {
   await setTelemetryState({ enabled: true, remoteFlushEnabled: telemetryConsent });
   emit("install", {
     phase: "started",
-    cli_version_to: "1.10.6",
+    cli_version_to: "1.10.8",
     agents_detected: agents.map((a) => a.kind),
     with_github: false,
     with_local_cc: false,
@@ -10809,8 +10809,8 @@ function ensureReachabilityGitHook() {
       }
       return "updated";
     }
-    const sep3 = cur.endsWith("\n") ? "" : "\n";
-    writeFileSync17(hookPath, cur + sep3 + "\n" + block + "\n");
+    const sep4 = cur.endsWith("\n") ? "" : "\n";
+    writeFileSync17(hookPath, cur + sep4 + "\n" + block + "\n");
     try {
       chmodSync5(hookPath, 493);
     } catch {
@@ -12030,10 +12030,10 @@ function confirmPurge() {
     return Promise.resolve(false);
   }
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     rl.question("   Type 'yes' to wipe everything (anything else cancels): ", (answer) => {
       rl.close();
-      resolve7(answer.trim().toLowerCase() === "yes");
+      resolve8(answer.trim().toLowerCase() === "yes");
     });
   });
 }
@@ -12286,7 +12286,7 @@ async function submitToChannel(role, payload, opts = {}) {
   const port = opts.port ?? CHANNEL_PORT;
   const startedAt = Date.now();
   try {
-    const result = await new Promise((resolve7, reject) => {
+    const result = await new Promise((resolve8, reject) => {
       const req = httpRequest({
         host: CHANNEL_HOST,
         port,
@@ -12312,7 +12312,7 @@ async function submitToChannel(role, payload, opts = {}) {
               reject(new LocalCCError(parsed.error));
               return;
             }
-            resolve7(String(parsed.result ?? ""));
+            resolve8(String(parsed.result ?? ""));
           } catch (err) {
             reject(new LocalCCError(`malformed channel response: ${text.slice(0, 200)}`, err));
           }
@@ -12338,14 +12338,14 @@ async function submitToChannel(role, payload, opts = {}) {
   }
 }
 function isChannelAvailable(port = CHANNEL_PORT, timeoutMs = 500) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const sock = connect(port, CHANNEL_HOST);
     const done = (ok) => {
       try {
         sock.destroy();
       } catch {
       }
-      resolve7(ok);
+      resolve8(ok);
     };
     sock.once("connect", () => done(true));
     sock.once("error", () => done(false));
@@ -12377,10 +12377,10 @@ __export(grade_exports, {
   gradeCommand: () => gradeCommand
 });
 async function readStdin() {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const chunks = [];
     process.stdin.on("data", (c) => chunks.push(c));
-    process.stdin.on("end", () => resolve7(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("end", () => resolve8(Buffer.concat(chunks).toString("utf-8")));
     process.stdin.on("error", reject);
   });
 }
@@ -12634,7 +12634,7 @@ function spawnClaudeJudge(file, claudeToken, promptHeader) {
 Diff:
 ${hunks}`;
   const fullPrompt = promptHeader + userMessage;
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const t0 = Date.now();
     const proc = spawn6(
       "claude",
@@ -12662,7 +12662,7 @@ ${hunks}`;
       const latencyMs = Date.now() - t0;
       if (code !== 0) {
         console.warn(`  claude exited ${code}: ${(stderr || stdout).slice(0, 500)}`);
-        resolve7({ findings: [], latencyMs });
+        resolve8({ findings: [], latencyMs });
         return;
       }
       try {
@@ -12681,10 +12681,10 @@ ${hunks}`;
           description: f.description,
           fix: f.fix
         }));
-        resolve7({ findings, latencyMs });
+        resolve8({ findings, latencyMs });
       } catch (parseErr) {
         console.warn(`  failed to parse claude response: ${stdout.slice(0, 300)}`);
-        resolve7({ findings: [], latencyMs });
+        resolve8({ findings: [], latencyMs });
       }
     });
   });
@@ -12733,7 +12733,7 @@ ${JSON.stringify(findings, null, 2)}
 `;
 }
 function spawnOpusConsolidator(findings, claudeToken) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const prompt = buildConsolidationPrompt(findings);
     const proc = spawn6(
       "claude",
@@ -12760,7 +12760,7 @@ function spawnOpusConsolidator(findings, claudeToken) {
     proc.on("close", (code) => {
       if (code !== 0) {
         console.warn(`  opus consolidation exited ${code}: ${(stderr || stdout).slice(0, 300)}`);
-        resolve7(fallbackReview(findings));
+        resolve8(fallbackReview(findings));
         return;
       }
       try {
@@ -12781,10 +12781,10 @@ function spawnOpusConsolidator(findings, claudeToken) {
           const order = ["low", "medium", "high", "critical"];
           return order.indexOf(f.severity) > order.indexOf(max) ? f.severity : max;
         }, "low");
-        resolve7({ summary: review.summary || "", comments, severity: maxSeverity });
+        resolve8({ summary: review.summary || "", comments, severity: maxSeverity });
       } catch {
         console.warn(`  failed to parse opus response, using fallback`);
-        resolve7(fallbackReview(findings));
+        resolve8(fallbackReview(findings));
       }
     });
   });
@@ -13267,14 +13267,14 @@ function ensureRunning(opts = {}) {
   return startTask(opts);
 }
 function probePort(host, port, timeoutMs = 500) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const sock = connect2(port, host);
     const done = (ok) => {
       try {
         sock.destroy();
       } catch {
       }
-      resolve7(ok);
+      resolve8(ok);
     };
     sock.once("connect", () => done(true));
     sock.once("error", () => done(false));
@@ -13824,7 +13824,7 @@ function cmdLogs(rest) {
     if (!raw) console.log("  " + colorize("(use --raw / -r to see full payloads, --live / -f to follow)", 90));
     return;
   }
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     console.log("  " + colorize("\u2014 following new turns (Ctrl-C to exit) \u2014", 90));
     const stop = followTurns((t) => {
       console.log("  " + formatTurn(t, raw));
@@ -13832,7 +13832,7 @@ function cmdLogs(rest) {
     const onSigint = () => {
       stop();
       process.removeListener("SIGINT", onSigint);
-      resolve7();
+      resolve8();
     };
     process.on("SIGINT", onSigint);
   });
@@ -14121,9 +14121,9 @@ function parseSession(file, seenStableIds) {
 }
 function ask2(q) {
   const rl = createInterface4({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve7) => rl.question(q, (a) => {
+  return new Promise((resolve8) => rl.question(q, (a) => {
     rl.close();
-    resolve7(/^y(es)?$/i.test(a.trim()));
+    resolve8(/^y(es)?$/i.test(a.trim()));
   }));
 }
 async function importCommand() {
@@ -14650,6 +14650,7 @@ function buildSpawnAgent(opts) {
     // and its own history scrolls — without it only the last screen is
     // reachable once the session is nested inside the layout.
     ["tmux", "set-option", "-t", session, "mouse", "on"],
+    ...buildClipboardBindings(session),
     ["tmux", "set-option", "-t", session, "-q", "@synkro_harness", opts.harness],
     ["tmux", "set-option", "-t", session, "-q", "@synkro_space", opts.space],
     ["tmux", "set-option", "-t", session, "-q", "@synkro_backend", opts.backend],
@@ -14658,6 +14659,13 @@ function buildSpawnAgent(opts) {
     ["tmux", "set-option", "-t", session, "remain-on-exit", "on"]
   ];
 }
+function buildClipboardBindings(session) {
+  return [
+    ["tmux", "set-option", "-t", session, "set-clipboard", "on"],
+    ["tmux", "bind-key", "-T", "copy-mode", "MouseDragEnd1Pane", "send-keys", "-X", "copy-pipe-and-cancel", SYSTEM_CLIPBOARD],
+    ["tmux", "bind-key", "-T", "copy-mode-vi", "MouseDragEnd1Pane", "send-keys", "-X", "copy-pipe-and-cancel", SYSTEM_CLIPBOARD]
+  ];
+}
 function buildListAgents() {
   return ["tmux", "list-sessions", "-F", ["#{session_name}", "#{?pane_dead,dead,alive}", "#{@synkro_harness}", "#{@synkro_space}", "#{@synkro_backend}", "#{@synkro_pueue}", "#{pane_current_path}"].join(FIELD_SEP)];
 }
@@ -14701,6 +14709,9 @@ function buildSendText(session, text) {
 function buildEnableMouse(session) {
   return ["tmux", "set-option", "-t", session, "mouse", "on"];
 }
+function buildKeepPaneAfterExit(pane) {
+  return ["tmux", "set-option", "-p", "-t", pane, "remain-on-exit", "on"];
+}
 function buildInterrupt(session) {
   return ["tmux", "send-keys", "-t", session, "Escape"];
 }
@@ -14767,7 +14778,7 @@ function parseWorktrees(porcelain) {
   }
   return rows;
 }
-var execFileAsync, AGENT_PREFIX, UI_SESSION, CONTAINER_USER, FIELD_SEP;
+var execFileAsync, AGENT_PREFIX, UI_SESSION, CONTAINER_USER, SYSTEM_CLIPBOARD, FIELD_SEP;
 var init_tmux = __esm({
   "cli/ui/tmux.ts"() {
     "use strict";
@@ -14775,6 +14786,7 @@ var init_tmux = __esm({
     AGENT_PREFIX = "synkro-agent-";
     UI_SESSION = "synkro-ui";
     CONTAINER_USER = "synkro";
+    SYSTEM_CLIPBOARD = "if command -v pbcopy >/dev/null 2>&1; then pbcopy; elif command -v wl-copy >/dev/null 2>&1; then wl-copy; elif command -v xclip >/dev/null 2>&1; then xclip -selection clipboard; else cat >/dev/null; fi";
     FIELD_SEP = "|";
   }
 });
@@ -14907,6 +14919,10 @@ function visibleAgents(all, space, filter, grouped) {
   if (grouped || filter === "all" || !space) return all;
   return all.filter((agent) => agent.repo === space.path);
 }
+function nextLiveAgent(all, preferredRepo = "") {
+  const live = all.filter((agent) => agent.status !== "offline" && agent.status !== "done");
+  return live.find((agent) => Boolean(preferredRepo) && agent.repo === preferredRepo) || live[0];
+}
 async function discoverAgents(runner, backend, memory) {
   const snapshot = await run(runner, buildAgentSnapshot());
   const { list, captures } = parseAgentSnapshot(snapshot.ok ? snapshot.stdout : "");
@@ -15172,6 +15188,7 @@ async function styleOuterSession(bootPath, repoCwd, sidebarWidth) {
     ["bind-key", "-n", "M-s", "select-pane", "-L"]
   ];
   for (const argv of style) await run(HOST, ["tmux", ...argv]);
+  for (const argv of buildClipboardBindings(UI_SESSION)) await run(HOST, argv);
 }
 async function buildTab(bootPath, repoCwd, spec) {
   await run(HOST, ["tmux", "set-option", "-g", "history-limit", "50000"]);
@@ -15214,6 +15231,7 @@ async function buildTab(bootPath, repoCwd, spec) {
   const sidebarPane = split.stdout.trim();
   const panes = await run(HOST, ["tmux", "list-panes", "-t", windowTarget, "-F", "#{pane_id}"]);
   const centerPane = panes.stdout.split("\n").map((line) => line.trim()).filter(Boolean).find((id) => id !== sidebarPane) || "";
+  await run(HOST, buildKeepPaneAfterExit(centerPane));
   if (spec.agentSession) {
     await run(HOST, ["tmux", "set-option", "-t", windowTarget, "-w", "-q", "@synkro_agent", spec.agentSession]);
   }
@@ -15593,6 +15611,9 @@ async function detectContainerBackend() {
   }
   return { runner: { kind: "host" }, backend: "host", note: "runtime: host (container unavailable)" };
 }
+function harnessCommand(request) {
+  return request.resume ? resumeCommand(request.harness) : HARNESS_COMMANDS[request.harness] || "claude";
+}
 async function provisionContainerWorkspace(runner, slug) {
   const dir = CONTAINER_WORK + "/ui-" + slug;
   await run(runner, [
@@ -15610,7 +15631,7 @@ async function spawnAgent(info, request) {
   if (request.backend === "container") {
     cwd = request.cwd.startsWith(CONTAINER_WORK) ? request.cwd : await provisionContainerWorkspace(runner, slug);
   }
-  const command = request.resume ? resumeCommand(request.harness) : HARNESS_COMMANDS[request.harness] || "claude";
+  const command = harnessCommand(request);
   for (const argv of buildSpawnAgent({ name: slug, cwd, command, harness: request.harness, space: cwd, backend: request.backend })) {
     const result = await run(runner, argv);
     if (!result.ok && argv[1] === "new-session") {
@@ -15901,6 +15922,24 @@ async function runSidebar() {
     const agent = state.agents[state.agentIndex];
     if (agent) await showAgent(agent);
   }
+  async function showWorkspaceTerminal(cwd) {
+    if (!centerPane || !cwd) return;
+    const command = makeTerminalCommand(bootPath);
+    const argv = ["tmux", "respawn-pane", "-k", "-t", centerPane, "-c", cwd];
+    if (command) argv.push(command);
+    const respawned = await run(host, argv);
+    if (!respawned.ok) {
+      state.message = "could not restore workspace terminal";
+      return;
+    }
+    const spaceName = cwd.split("/").filter(Boolean).pop() || "space";
+    await run(host, ["tmux", "set-option", "-t", centerPane, "-w", "-u", "@synkro_agent"]);
+    await run(host, ["tmux", "set-option", "-t", centerPane, "-w", "-q", "@synkro_cwd", cwd]);
+    await run(host, ["tmux", "set-option", "-t", centerPane, "-w", "-q", "@synkro_kind", "terminal"]);
+    await run(host, ["tmux", "rename-window", "-t", centerPane, tabTitle("terminal", spaceName)]);
+    state.viewing = "";
+    await snapshotTabs();
+  }
   async function showAgent(agent) {
     if (!centerPane) return;
     if (agent.status === "offline") {
@@ -15919,6 +15958,9 @@ async function runSidebar() {
       return;
     }
     await run(runnerFor(agent.backend), buildEnableMouse(agent.session));
+    for (const argv of buildClipboardBindings(agent.session)) {
+      await run(runnerFor(agent.backend), argv);
+    }
     const command = buildCenterAttachCommand(runnerFor(agent.backend), agent.session);
     await run(host, ["tmux", "respawn-pane", "-k", "-t", centerPane, command]);
     const where = agent.space ? agent.space.split("/").filter(Boolean).pop() || "" : "";
@@ -15931,7 +15973,15 @@ async function runSidebar() {
   async function confirmKillAgent() {
     const agent = state.agents[state.agentIndex];
     if (!agent) return;
+    const wasViewing = state.viewing === agent.session;
     await openDialog("kill", [agent.backend, agent.session]);
+    await refresh();
+    if (allAgents.some((candidate) => candidate.session === agent.session && candidate.status !== "offline")) return;
+    state.message = "closed " + agent.name;
+    if (!wasViewing) return;
+    await showWorkspaceTerminal(agent.space || selectedSpace()?.path || repoCwd);
+    const successor = nextLiveAgent(allAgents, agent.repo || "");
+    if (successor) await showAgent(successor);
   }
   async function consent(action) {
     const agent = state.agents[state.agentIndex];
@@ -15954,6 +16004,7 @@ async function runSidebar() {
       const remembered = space ? lastAgentFor(space.path) : "";
       const agent = allAgents.find((row2) => row2.session === remembered && row2.status !== "offline");
       if (agent) await showAgent(agent);
+      else if (space) await showWorkspaceTerminal(space.path);
     } else if (target.kind === "agent") {
       state.section = "agents";
       state.agentIndex = target.index;
@@ -16155,6 +16206,9 @@ var init_repos = __esm({
 
 // cli/ui/tabs.ts
 import { execSync as execSync7 } from "child_process";
+function isLegacyCodexRenderer(command) {
+  return /(?:^|\s)ui\s+--run\s+codex(?:\s|$)/.test(String(command || "").trim());
+}
 function repoRoot() {
   try {
     return execSync7("git rev-parse --show-toplevel", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim() || process.cwd();
@@ -16175,16 +16229,6 @@ async function createTab(bootPath, kind, spacePath) {
     });
     return;
   }
-  if (kind === "cursor-synkro") {
-    await buildTab(bootPath, repo, {
-      cwd: spacePath,
-      center: ["node", bootPath, "ui", "--run", "cursor", spacePath].map(shellQuote3).join(" "),
-      title: tabTitle("cursor", space),
-      kind: "cursor-synkro",
-      focus: "center"
-    });
-    return;
-  }
   if (kind === "settings") {
     await buildTab(bootPath, repo, {
       cwd: spacePath,
@@ -16195,12 +16239,13 @@ async function createTab(bootPath, kind, spacePath) {
     });
     return;
   }
+  if (!["claude", "codex", "cursor"].includes(kind)) return;
   const info = await detectContainerBackend();
   const spaceName = space;
   const stamp = String(process.pid % 1e4);
-  const harness = ["claude", "codex", "cursor"].includes(kind) ? kind : "claude";
+  const harness = kind;
   const reachable = info.backend === "container" && (await run(info.runner, ["test", "-d", spacePath])).ok;
-  const backend = reachable ? "container" : "host";
+  const backend = harness === "codex" ? "host" : reachable ? "container" : "host";
   const spawned = await spawnAgent(info, {
     name: spaceName + "-" + harness + "-" + stamp,
     harness,
@@ -16231,16 +16276,34 @@ async function openAgentTab(bootPath, session) {
   ]);
   const [harness, space, backend] = (meta.stdout.trim() || "||").split("|");
   const containerHosted = backend === "container";
-  const runner = containerHosted ? info.runner : HOST2;
-  const alive = (await run(runner, ["tmux", "has-session", "-t", session])).ok;
-  if (!alive) return;
+  let runner = containerHosted ? info.runner : HOST2;
+  let activeSession = session;
   const spaceName = (space || "").split("/").filter(Boolean).pop() || "space";
+  if (harness === "codex") {
+    const command = await run(HOST2, ["tmux", "display-message", "-p", "-t", session, "#{pane_start_command}"]);
+    if (command.ok && isLegacyCodexRenderer(command.stdout)) {
+      await run(HOST2, buildKillSession(session));
+      const restored = await spawnAgent(info, {
+        name: session.replace(/^synkro-agent-/, ""),
+        harness: "codex",
+        spaceName,
+        cwd: space || repoRoot(),
+        backend: "host",
+        resume: true
+      });
+      if (!restored.ok) return;
+      activeSession = restored.session;
+      runner = HOST2;
+    }
+  }
+  const alive = (await run(runner, ["tmux", "has-session", "-t", activeSession])).ok;
+  if (!alive) return;
   await buildTab(bootPath, repoRoot(), {
     cwd: space || repoRoot(),
-    center: buildCenterAttachCommand(runner, session),
+    center: buildCenterAttachCommand(runner, activeSession),
     title: tabTitle(harness || "claude", spaceName),
     kind: harness || "claude",
-    agentSession: session,
+    agentSession: activeSession,
     focus: "center"
   });
 }
@@ -16256,11 +16319,23 @@ async function restoreTabs(bootPath, repoCwd) {
     const space = tab.cwd.split("/").filter(Boolean).pop() || "space";
     const containerHosted = info.backend === "container" && (await run(info.runner, ["test", "-d", tab.cwd])).ok;
     const harness = ["claude", "codex", "cursor"].includes(tab.kind) ? tab.kind : "";
-    if (tab.agentSession && alive.has(tab.agentSession)) {
-      await run(containerHosted ? info.runner : HOST2, buildEnableMouse(tab.agentSession));
+    const sessionRunner = harness === "codex" ? HOST2 : containerHosted ? info.runner : HOST2;
+    let sessionAlive = Boolean(tab.agentSession && alive.has(tab.agentSession));
+    if (sessionAlive && harness === "codex") {
+      const command = await run(HOST2, ["tmux", "display-message", "-p", "-t", tab.agentSession, "#{pane_start_command}"]);
+      if (command.ok && isLegacyCodexRenderer(command.stdout)) {
+        await run(HOST2, buildKillSession(tab.agentSession));
+        sessionAlive = false;
+      }
+    }
+    if (tab.agentSession && sessionAlive) {
+      await run(sessionRunner, buildEnableMouse(tab.agentSession));
+      for (const argv of buildClipboardBindings(tab.agentSession)) {
+        await run(sessionRunner, argv);
+      }
       await buildTab(bootPath, repoCwd, {
         cwd: tab.cwd,
-        center: buildCenterAttachCommand(containerHosted ? info.runner : HOST2, tab.agentSession),
+        center: buildCenterAttachCommand(sessionRunner, tab.agentSession),
         title: tab.title,
         kind: tab.kind,
         agentSession: tab.agentSession,
@@ -16272,12 +16347,13 @@ async function restoreTabs(bootPath, repoCwd) {
         harness,
         spaceName: space,
         cwd: tab.cwd,
-        backend: containerHosted ? "container" : "host",
+        backend: harness === "codex" ? "host" : containerHosted ? "container" : "host",
         resume: true
       });
+      const restoredInContainer = harness !== "codex" && containerHosted;
       await buildTab(bootPath, repoCwd, spawned.ok ? {
         cwd: tab.cwd,
-        center: buildCenterAttachCommand(containerHosted ? info.runner : HOST2, spawned.session),
+        center: buildCenterAttachCommand(restoredInContainer ? info.runner : HOST2, spawned.session),
         title: tabTitle(harness, space),
         kind: harness,
         agentSession: spawned.session,
@@ -16370,7 +16446,7 @@ async function pick(opts) {
   const perItem = opts.choices.some((choice) => choice.detail) ? 2 : 1;
   const visibleItems = Math.max(1, Math.floor(Math.max(2, height - 5) / perItem));
   const firstRow = 4;
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const view = () => opts.choices.filter((choice) => matches(choice, filter));
     const draw = () => {
       const shown = view();
@@ -16418,7 +16494,7 @@ async function pick(opts) {
           const hit = shown.findIndex((_, index) => y >= rowOfItem(index) && y < rowOfItem(index) + perItem);
           if (hit >= 0) {
             process.stdin.off("data", onData);
-            resolve7(shown[hit].value);
+            resolve8(shown[hit].value);
             return;
           }
         }
@@ -16426,13 +16502,13 @@ async function pick(opts) {
       if (!sawMouse) {
         if (input === KEY_ESC && !input.includes("[<") || input === KEY_CTRL_C2) {
           process.stdin.off("data", onData);
-          resolve7(null);
+          resolve8(null);
           return;
         }
         if (input === "\r") {
           if (shown.length === 0) return;
           process.stdin.off("data", onData);
-          resolve7(shown[selected].value);
+          resolve8(shown[selected].value);
           return;
         }
         const down = input === CSI2 + "B" || opts.menu && (input === "j" || input === CSI2 + "C");
@@ -16456,7 +16532,7 @@ async function readLine(opts) {
   let value = "";
   let error = "";
   const width = Math.max(20, Number(process.stdout.columns || 80));
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const draw = () => {
       const lines = [
         " " + S.title + opts.title + S.reset,
@@ -16475,7 +16551,7 @@ async function readLine(opts) {
       const input = chunk.toString("utf8");
       if (input === KEY_ESC || input === KEY_CTRL_C2) {
         process.stdin.off("data", onData);
-        resolve7(null);
+        resolve8(null);
         return;
       }
       if (input === "\r") {
@@ -16487,7 +16563,7 @@ async function readLine(opts) {
             return;
           }
           process.stdin.off("data", onData);
-          resolve7(value.trim());
+          resolve8(value.trim());
         })();
         return;
       }
@@ -16754,9 +16830,6 @@ async function runDialog(kind, repoCwd, argA = "", argB = "") {
       label: (TAB_GLYPHS[harness] || "") + "  " + (HARNESS_LABELS[harness] || harness)
     }))
   ];
-  if (harnesses.includes("cursor")) {
-    sessions.push({ value: "cursor-synkro", label: TAB_GLYPHS.cursor + "  Cursor in Synkro UX" });
-  }
   for (; ; ) {
     const session = await pick({
       menu: true,
@@ -16815,21 +16888,418 @@ var init_dialog = __esm({
   }
 });
 
+// cli/harness/render.ts
+function spinnerFrame(tick) {
+  return SPINNER[Math.abs(tick) % SPINNER.length];
+}
+function terminalText(text) {
+  return String(text).replace(/[\u0000-\u001F\u007F-\u009F]/g, "");
+}
+function clip3(text, max) {
+  const value = String(text || "").replace(/\s+/g, " ").trim();
+  if (max <= 1) return value;
+  return value.length <= max ? value : value.slice(0, max - 1) + "\u2026";
+}
+function seconds(ms) {
+  const total = Math.max(0, Math.round(ms / 1e3));
+  if (total < 60) return total + "s";
+  return Math.floor(total / 60) + "m" + String(total % 60).padStart(2, "0") + "s";
+}
+function statusLine(opts) {
+  const hint = opts.hint ? " \xB7 " + opts.hint : "";
+  const body = opts.text + " (" + seconds(opts.elapsedMs) + hint + ")";
+  const width = Math.max(20, (opts.width || 100) - 4);
+  return S2.think + "  " + spinnerFrame(opts.tick) + " " + clip3(body, width) + S2.reset;
+}
+function renderEvent(event, width = 100) {
+  const body = Math.max(30, width - 4);
+  switch (event.type) {
+    // The workspace and both accounts are already in the session header, so
+    // this line carries only what the header could not know before the harness
+    // started: which model answered, and whether a subscription or a key paid.
+    case "session-start":
+      return [
+        "",
+        S2.dim + "  " + clip3(event.model, body - 20) + (event.authSource === "login" ? "  \xB7  subscription" : "  \xB7  api key") + S2.reset,
+        ""
+      ];
+    case "user-message":
+      return ["", S2.user + "  \u276F " + S2.reset + S2.bold + clip3(event.text, body) + S2.reset, ""];
+    // Live state, not transcript. The runner promotes these to the status line.
+    case "thinking":
+      return [];
+    case "assistant-message": {
+      const lines = wrap(event.text, body - 2);
+      return [
+        "",
+        ...lines.map((line, index) => index === 0 ? S2.agent + "  " + BULLET + " " + line + S2.reset : S2.agent + "    " + line + S2.reset),
+        ""
+      ];
+    }
+    case "tool-start": {
+      const label = TOOL_LABEL[event.kind] || TOOL_LABEL.other;
+      return [
+        S2.tool + "  " + BULLET + " " + label + S2.reset + S2.dim + "(" + clip3(event.target, body - label.length - 8) + ")" + S2.reset
+      ];
+    }
+    case "tool-end": {
+      if (event.blocked) {
+        return [
+          S2.blocked + "  " + BULLET + " Blocked" + S2.reset + S2.dim + "  " + clip3(terminalText(event.target), body - 14) + S2.reset,
+          ...wrap(terminalText(event.reason), body - 6).map((line, index) => index === 0 ? S2.blocked + "    " + ELBOW + " " + S2.reset + S2.rule + line + S2.reset : S2.rule + "      " + line + S2.reset)
+        ];
+      }
+      const detail = event.ok ? event.output.trim() ? clip3(terminalText(event.output), body - 10) : "done" : "failed" + (event.exitCode === null ? "" : " (exit " + event.exitCode + ")");
+      const tint = event.ok ? S2.ok : S2.blocked;
+      return [tint + "    " + ELBOW + " " + S2.reset + S2.dim + detail + S2.reset];
+    }
+    // A clean finish needs no announcement: the prompt returning IS the signal.
+    case "turn-end":
+      return event.ok ? [] : ["", S2.blocked + "  " + BULLET + " turn ended with an error" + S2.reset, ""];
+    case "notice":
+      return [S2.dim + "  " + clip3(event.text, body) + S2.reset];
+    default:
+      return [];
+  }
+}
+function wrap(text, width) {
+  const words = String(text || "").replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+  if (words.length === 0) return [];
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if (!line) line = word;
+    else if ((line + " " + word).length <= width) line += " " + word;
+    else {
+      lines.push(line);
+      line = word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines;
+}
+var ESC2, S2, CLEAR_LINE, BULLET, ELBOW, SPINNER, TOOL_LABEL;
+var init_render2 = __esm({
+  "cli/harness/render.ts"() {
+    "use strict";
+    ESC2 = "\x1B[";
+    S2 = {
+      reset: ESC2 + "0m",
+      dim: ESC2 + "2m",
+      bold: ESC2 + "1m",
+      user: ESC2 + "38;5;111m",
+      agent: ESC2 + "38;5;252m",
+      think: ESC2 + "38;5;244m",
+      tool: ESC2 + "38;5;180m",
+      ok: ESC2 + "38;5;114m",
+      blocked: ESC2 + "38;5;203m",
+      rule: ESC2 + "38;5;211m"
+    };
+    CLEAR_LINE = "\r" + ESC2 + "2K";
+    BULLET = "\u23FA";
+    ELBOW = "\u23BF";
+    SPINNER = ["\xB7", "\u2722", "\u2733", "\u2217", "\u273B", "\u273D"];
+    TOOL_LABEL = {
+      shell: "Shell",
+      read: "Read",
+      edit: "Edit",
+      write: "Write",
+      delete: "Delete",
+      search: "Search",
+      list: "List",
+      todo: "Todo",
+      other: "Tool"
+    };
+  }
+});
+
+// cli/harness/composer.ts
+import { execFileSync as execFileSync5, spawnSync as spawnSync12 } from "child_process";
+import { existsSync as existsSync38, mkdtempSync as mkdtempSync2, rmSync as rmSync7, statSync as statSync5, writeFileSync as writeFileSync27 } from "fs";
+import { homedir as homedir38, tmpdir } from "os";
+import { basename as basename3, dirname as dirname12, extname, isAbsolute as isAbsolute2, join as join37, resolve as resolve5, sep as sep3 } from "path";
+import { createInterface as createInterface5 } from "readline";
+function markerCarryLength(input, marker) {
+  for (let length = Math.min(input.length, marker.length - 1); length > 0; length -= 1) {
+    if (marker.startsWith(input.slice(-length))) return length;
+  }
+  return 0;
+}
+function normalizePathToken(raw) {
+  let value = raw.trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  value = value.replace(/\\([\\ "'()])/g, "$1");
+  if (value === "~") return homedir38();
+  if (value.startsWith("~/")) return join37(homedir38(), value.slice(2));
+  return value;
+}
+function imagePathsInText(text, cwd) {
+  const candidates = String(text || "").match(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|(?:\\.|[^\s])+/g) || [];
+  const images = [];
+  for (const candidate of candidates) {
+    const token = normalizePathToken(candidate);
+    if (!IMAGE_EXTENSIONS.has(extname(token).toLowerCase())) continue;
+    const path = isAbsolute2(token) ? token : resolve5(cwd, token);
+    try {
+      if (statSync5(path).isFile() && !images.includes(path)) images.push(path);
+    } catch {
+    }
+  }
+  return images;
+}
+function codexUserInput(draft) {
+  const input = [];
+  if (draft.text.trim()) input.push({ type: "text", text: draft.text, text_elements: [] });
+  for (const path of draft.images) input.push({ type: "localImage", path });
+  return input;
+}
+function clipboardText() {
+  try {
+    if (process.platform === "darwin") return execFileSync5("pbpaste", [], { encoding: "utf8", timeout: 1500 });
+    const wayland = spawnSync12("wl-paste", ["--no-newline"], { encoding: "utf8", timeout: 1500 });
+    if (wayland.status === 0) return String(wayland.stdout || "");
+    const x11 = spawnSync12("xclip", ["-selection", "clipboard", "-o"], { encoding: "utf8", timeout: 1500 });
+    return x11.status === 0 ? String(x11.stdout || "") : "";
+  } catch {
+    return "";
+  }
+}
+function macClipboardPng(target) {
+  const script = [
+    "on run argv",
+    "set outputPath to item 1 of argv",
+    "set imageData to the clipboard as \xABclass PNGf\xBB",
+    "set outputFile to open for access POSIX file outputPath with write permission",
+    "set eof outputFile to 0",
+    "write imageData to outputFile",
+    "close access outputFile",
+    "end run"
+  ].join("\n");
+  const result = spawnSync12("osascript", ["-e", script, target], { encoding: "utf8", timeout: 3e3 });
+  return result.status === 0 && existsSync38(target);
+}
+function linuxClipboardPng(target) {
+  const wayland = spawnSync12("wl-paste", ["--type", "image/png"], { encoding: null, timeout: 3e3 });
+  if (wayland.status === 0 && Buffer.isBuffer(wayland.stdout) && wayland.stdout.length > 0) {
+    writeFileSync27(target, wayland.stdout);
+    return true;
+  }
+  const x11 = spawnSync12("xclip", ["-selection", "clipboard", "-t", "image/png", "-o"], { encoding: null, timeout: 3e3 });
+  if (x11.status === 0 && Buffer.isBuffer(x11.stdout) && x11.stdout.length > 0) {
+    writeFileSync27(target, x11.stdout);
+    return true;
+  }
+  return false;
+}
+function clipboardImage() {
+  const directory = mkdtempSync2(join37(tmpdir(), "synkro-paste-"));
+  const target = join37(directory, "clipboard.png");
+  try {
+    const copied = process.platform === "darwin" ? macClipboardPng(target) : process.platform === "linux" && linuxClipboardPng(target);
+    if (copied && statSync5(target).size > 0) return target;
+  } catch {
+  }
+  rmSync7(directory, { recursive: true, force: true });
+  return "";
+}
+function cleanupPromptDraft(draft) {
+  for (const path of draft.temporaryImages) {
+    const directory = dirname12(resolve5(path));
+    const temporaryRoot = resolve5(tmpdir()) + sep3;
+    if (!directory.startsWith(temporaryRoot) || !basename3(directory).startsWith("synkro-paste-")) continue;
+    try {
+      rmSync7(directory, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function fallbackPrompt(cwd) {
+  return new Promise((resolveDraft) => {
+    const rl = createInterface5({ input: process.stdin, output: process.stdout });
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      rl.close();
+      resolveDraft(value);
+    };
+    rl.once("close", () => finish(null));
+    rl.once("SIGINT", () => finish(null));
+    rl.question(S2.user + "  \u276F " + S2.reset, (text) => {
+      finish({ text, images: imagePathsInText(text, cwd), temporaryImages: [] });
+    });
+  });
+}
+function readPrompt(cwd) {
+  const input = process.stdin;
+  const output = process.stdout;
+  if (!input.isTTY || !output.isTTY || !input.setRawMode) return fallbackPrompt(cwd);
+  return new Promise((resolveDraft) => {
+    let text = "";
+    let cursor = 0;
+    let stream = "";
+    let pasting = false;
+    let settled = false;
+    const images = [];
+    const temporaryImages = [];
+    const wasRaw = Boolean(input.isRaw);
+    const prompt = S2.user + "  \u276F " + S2.reset;
+    const redraw = () => {
+      const safe = text.replace(/[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g, "").replace(/[\r\n]+/g, " / ");
+      const attachmentLabel = images.length ? "  [" + images.length + " image" + (images.length === 1 ? "" : "s") + "]" : "";
+      const attachments = attachmentLabel ? S2.dim + attachmentLabel + S2.reset : "";
+      output.write("\r\x1B[2K" + prompt + safe + attachments);
+      const after = text.slice(cursor).replace(/[\r\n]+/g, " / ").length + attachmentLabel.length;
+      if (after > 0) output.write("\x1B[" + after + "D");
+    };
+    const finish = (draft) => {
+      if (settled) return;
+      settled = true;
+      input.off("data", onData);
+      input.setRawMode?.(wasRaw);
+      output.write("\x1B[?2004l\n");
+      if (!draft) cleanupPromptDraft({ temporaryImages });
+      resolveDraft(draft);
+    };
+    const insert = (value) => {
+      text = text.slice(0, cursor) + value + text.slice(cursor);
+      cursor += value.length;
+    };
+    const attachClipboard = () => {
+      const image = clipboardImage();
+      if (image) {
+        images.push(image);
+        temporaryImages.push(image);
+        return;
+      }
+      insert(clipboardText());
+    };
+    const processStream = () => {
+      while (stream && !settled) {
+        if (pasting) {
+          const end = stream.indexOf(PASTE_END);
+          if (end < 0) {
+            const keep = markerCarryLength(stream, PASTE_END);
+            insert(stream.slice(0, stream.length - keep));
+            stream = stream.slice(stream.length - keep);
+            break;
+          }
+          insert(stream.slice(0, end));
+          stream = stream.slice(end + PASTE_END.length);
+          pasting = false;
+          continue;
+        }
+        if (stream.startsWith(PASTE_START)) {
+          stream = stream.slice(PASTE_START.length);
+          pasting = true;
+          continue;
+        }
+        if (PASTE_START.startsWith(stream)) break;
+        if (stream.startsWith("\x1B[D")) {
+          cursor = Math.max(0, cursor - 1);
+          stream = stream.slice(3);
+          continue;
+        }
+        if (stream.startsWith("\x1B[C")) {
+          cursor = Math.min(text.length, cursor + 1);
+          stream = stream.slice(3);
+          continue;
+        }
+        if (stream.startsWith("\x1B[H")) {
+          cursor = 0;
+          stream = stream.slice(3);
+          continue;
+        }
+        if (stream.startsWith("\x1B[F")) {
+          cursor = text.length;
+          stream = stream.slice(3);
+          continue;
+        }
+        if (stream.startsWith("\x1B[A") || stream.startsWith("\x1B[B")) {
+          stream = stream.slice(3);
+          continue;
+        }
+        if (stream.startsWith("\x1B") && stream.length < 3) break;
+        const char = stream[0];
+        stream = stream.slice(1);
+        if (char === "\r" || char === "\n") {
+          const found = imagePathsInText(text, cwd);
+          for (const path of found) if (!images.includes(path)) images.push(path);
+          finish({ text, images, temporaryImages });
+        } else if (char === "" || char === "" && !text && images.length === 0) {
+          finish(null);
+        } else if (char === "\x7F" || char === "\b") {
+          if (cursor > 0) {
+            text = text.slice(0, cursor - 1) + text.slice(cursor);
+            cursor -= 1;
+          }
+        } else if (char === "") {
+          text = text.slice(cursor);
+          cursor = 0;
+        } else if (char === "") {
+          const before = text.slice(0, cursor).replace(/\s*\S+\s*$/, "");
+          text = before + text.slice(cursor);
+          cursor = before.length;
+        } else if (char === "") {
+          attachClipboard();
+        } else if (char >= " " || char === "	") {
+          insert(char);
+        }
+      }
+      if (!settled) redraw();
+    };
+    let queue = Promise.resolve();
+    const onData = (chunk) => {
+      queue = queue.then(() => {
+        stream += chunk.toString("utf8");
+        processStream();
+      });
+    };
+    input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+    output.write("\x1B[?2004h" + prompt);
+  });
+}
+var PASTE_START, PASTE_END, IMAGE_EXTENSIONS;
+var init_composer = __esm({
+  "cli/harness/composer.ts"() {
+    "use strict";
+    init_render2();
+    PASTE_START = "\x1B[200~";
+    PASTE_END = "\x1B[201~";
+    IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp"]);
+  }
+});
+
 // cli/harness/events.ts
+function fixPollId(raw) {
+  const text = String(raw || "");
+  return FIX_POLL_MARKER.exec(text)?.[1] || LEGACY_FIX_POLL_MARKER.exec(text)?.[1] || "";
+}
+function cleanGuardText(raw) {
+  return String(raw || "").replace(FIX_POLL_MARKER, "").replace(/\n*\s*SYNKRO FIX POLL[\s\S]*$/i, "").replace(/\n?\d{4}-\d\d-\d\dT[^\n]*\sERROR\s+codex_core::tools::router:[^\n]*/gi, "").replace(/\s*Checking command\s*$/i, "").trim();
+}
 function blockReason(raw) {
-  const text = String(raw || "").trim();
+  const text = cleanGuardText(raw);
   if (!text) return "blocked by policy";
+  const guardAt = text.lastIndexOf("Guard:");
+  if (guardAt >= 0) return text.slice(guardAt + "Guard:".length).trim();
   const afterTag = text.match(/\[synkro:[^\]]*\]\s*(.+)/is);
   if (afterTag) return afterTag[1].trim();
   const afterHook = text.match(/blocked by a hook:\s*(.+)/is);
   if (afterHook) return afterHook[1].trim();
   return text;
 }
-var BLOCK_MARKER;
+var BLOCK_MARKER, FIX_POLL_MARKER, LEGACY_FIX_POLL_MARKER;
 var init_events = __esm({
   "cli/harness/events.ts"() {
     "use strict";
     BLOCK_MARKER = /blocked by a hook|\[synkro:/i;
+    FIX_POLL_MARKER = /\[synkro:fix-poll\s+item_id=\\?["']?([A-Za-z0-9_-]+)\\?["']?\]/i;
+    LEGACY_FIX_POLL_MARKER = /SYNKRO FIX POLL\s*\(item_id=([A-Za-z0-9_-]+)\)/i;
   }
 });
 
@@ -16910,6 +17380,7 @@ function parseCursorLine(line) {
         ok: Boolean(success) && Number(success?.exitCode ?? 0) === 0,
         blocked,
         reason: rejected ? blocked ? blockReason(rawReason) : rawReason || "rejected" : "",
+        pollId: blocked ? fixPollId(rawReason) : "",
         exitCode: success ? Number(success.exitCode ?? 0) : null,
         output: String(success?.stdout || success?.stderr || "")
       }];
@@ -16981,128 +17452,6 @@ var init_cursor = __esm({
   }
 });
 
-// cli/harness/render.ts
-function spinnerFrame(tick) {
-  return SPINNER[Math.abs(tick) % SPINNER.length];
-}
-function clip3(text, max) {
-  const value = String(text || "").replace(/\s+/g, " ").trim();
-  if (max <= 1) return value;
-  return value.length <= max ? value : value.slice(0, max - 1) + "\u2026";
-}
-function seconds(ms) {
-  const total = Math.max(0, Math.round(ms / 1e3));
-  if (total < 60) return total + "s";
-  return Math.floor(total / 60) + "m" + String(total % 60).padStart(2, "0") + "s";
-}
-function statusLine(opts) {
-  const hint = opts.hint ? " \xB7 " + opts.hint : "";
-  const body = opts.text + " (" + seconds(opts.elapsedMs) + hint + ")";
-  const width = Math.max(20, (opts.width || 100) - 4);
-  return S2.think + "  " + spinnerFrame(opts.tick) + " " + clip3(body, width) + S2.reset;
-}
-function renderEvent(event, width = 100) {
-  const body = Math.max(30, width - 4);
-  switch (event.type) {
-    // The workspace and both accounts are already in the session header, so
-    // this line carries only what the header could not know before the harness
-    // started: which model answered, and whether a subscription or a key paid.
-    case "session-start":
-      return [
-        "",
-        S2.dim + "  " + clip3(event.model, body - 20) + (event.authSource === "login" ? "  \xB7  subscription" : "  \xB7  api key") + S2.reset,
-        ""
-      ];
-    case "user-message":
-      return ["", S2.user + "  \u276F " + S2.reset + S2.bold + clip3(event.text, body) + S2.reset, ""];
-    // Live state, not transcript. The runner promotes these to the status line.
-    case "thinking":
-      return [];
-    case "assistant-message": {
-      const lines = wrap(event.text, body - 2);
-      return [
-        "",
-        ...lines.map((line, index) => index === 0 ? S2.agent + "  " + BULLET + " " + line + S2.reset : S2.agent + "    " + line + S2.reset),
-        ""
-      ];
-    }
-    case "tool-start": {
-      const label = TOOL_LABEL[event.kind] || TOOL_LABEL.other;
-      return [
-        S2.tool + "  " + BULLET + " " + label + S2.reset + S2.dim + "(" + clip3(event.target, body - label.length - 8) + ")" + S2.reset
-      ];
-    }
-    case "tool-end": {
-      if (event.blocked) {
-        return [
-          S2.blocked + "  " + BULLET + " Blocked" + S2.reset + S2.dim + "  " + clip3(event.target, body - 14) + S2.reset,
-          ...wrap(event.reason, body - 6).map((line, index) => index === 0 ? S2.blocked + "    " + ELBOW + " " + S2.reset + S2.rule + line + S2.reset : S2.rule + "      " + line + S2.reset)
-        ];
-      }
-      const detail = event.ok ? event.output.trim() ? clip3(event.output, body - 10) : "done" : "failed" + (event.exitCode === null ? "" : " (exit " + event.exitCode + ")");
-      const tint = event.ok ? S2.ok : S2.blocked;
-      return [tint + "    " + ELBOW + " " + S2.reset + S2.dim + detail + S2.reset];
-    }
-    // A clean finish needs no announcement: the prompt returning IS the signal.
-    case "turn-end":
-      return event.ok ? [] : ["", S2.blocked + "  " + BULLET + " turn ended with an error" + S2.reset, ""];
-    case "notice":
-      return [S2.dim + "  " + clip3(event.text, body) + S2.reset];
-    default:
-      return [];
-  }
-}
-function wrap(text, width) {
-  const words = String(text || "").replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
-  if (words.length === 0) return [];
-  const lines = [];
-  let line = "";
-  for (const word of words) {
-    if (!line) line = word;
-    else if ((line + " " + word).length <= width) line += " " + word;
-    else {
-      lines.push(line);
-      line = word;
-    }
-  }
-  if (line) lines.push(line);
-  return lines;
-}
-var ESC2, S2, CLEAR_LINE, BULLET, ELBOW, SPINNER, TOOL_LABEL;
-var init_render2 = __esm({
-  "cli/harness/render.ts"() {
-    "use strict";
-    ESC2 = "\x1B[";
-    S2 = {
-      reset: ESC2 + "0m",
-      dim: ESC2 + "2m",
-      bold: ESC2 + "1m",
-      user: ESC2 + "38;5;111m",
-      agent: ESC2 + "38;5;252m",
-      think: ESC2 + "38;5;244m",
-      tool: ESC2 + "38;5;180m",
-      ok: ESC2 + "38;5;114m",
-      blocked: ESC2 + "38;5;203m",
-      rule: ESC2 + "38;5;211m"
-    };
-    CLEAR_LINE = "\r" + ESC2 + "2K";
-    BULLET = "\u23FA";
-    ELBOW = "\u23BF";
-    SPINNER = ["\xB7", "\u2722", "\u2733", "\u2217", "\u273B", "\u273D"];
-    TOOL_LABEL = {
-      shell: "Shell",
-      read: "Read",
-      edit: "Edit",
-      write: "Write",
-      delete: "Delete",
-      search: "Search",
-      list: "List",
-      todo: "Todo",
-      other: "Tool"
-    };
-  }
-});
-
 // cli/harness/run.ts
 import { spawn as spawn9 } from "child_process";
 function replayKey(event) {
@@ -17131,6 +17480,7 @@ function createTurnSink(opts) {
   let buffer = "";
   let reconnecting = false;
   let lastWasAnswer = false;
+  const toolStartedAt = /* @__PURE__ */ new Map();
   let statusText = "";
   let statusKind = "progress";
   let statusShown = false;
@@ -17233,7 +17583,17 @@ function createTurnSink(opts) {
     opts.write(rendered.join("\n") + "\n");
     drawStatus();
   };
-  const take = (event) => {
+  const take = (incoming) => {
+    let event = incoming;
+    if (event.type === "tool-start" && event.id && !toolStartedAt.has(event.id)) {
+      toolStartedAt.set(event.id, now());
+    } else if (event.type === "tool-end") {
+      const started = toolStartedAt.get(event.id);
+      if ((event.durationMs === null || event.durationMs === void 0) && started !== void 0) {
+        event = { ...event, durationMs: Math.max(0, now() - started) };
+      }
+      toolStartedAt.delete(event.id);
+    }
     const isRetry = event.type === "notice" && event.kind === "retry";
     if (!isRetry) disarmStall();
     if (isRetry) {
@@ -17266,6 +17626,9 @@ function createTurnSink(opts) {
     notice(text) {
       emit2({ type: "notice", text });
     },
+    event(event) {
+      take(event);
+    },
     finish(exit, interrupted = false) {
       disarmStall();
       stopStatus();
@@ -17299,7 +17662,7 @@ async function runCursorTurn(opts) {
     showHeader: opts.showHeader,
     onGiveUp: () => stopHarness()
   });
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn9("cursor-agent", cursorArgs(opts.prompt), {
       cwd: opts.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -17328,11 +17691,11 @@ async function runCursorTurn(opts) {
     });
     child.on("close", (code) => {
       opts.signal?.removeEventListener("abort", onAbort);
-      resolve7(sink.finish(code ?? 0, interrupted));
+      resolve8(sink.finish(code ?? 0, interrupted));
     });
     child.on("error", (error) => {
       sink.notice("failed to start cursor-agent: " + String(error));
-      resolve7(sink.finish(1, interrupted));
+      resolve8(sink.finish(1, interrupted));
     });
   });
 }
@@ -17346,10 +17709,474 @@ var init_run = __esm({
   }
 });
 
+// cli/harness/codex.ts
+import { spawn as spawn10 } from "child_process";
+function itemTarget(item) {
+  if (item?.type === "commandExecution") {
+    return { kind: "shell", target: String(item.command || ""), description: "" };
+  }
+  if (item?.type === "fileChange") {
+    const paths = Array.isArray(item.changes) ? item.changes.map((change) => String(change?.path || "")).filter(Boolean) : [];
+    return { kind: "edit", target: paths.join(", ") || "files", description: "" };
+  }
+  if (item?.type === "mcpToolCall") {
+    return { kind: "other", target: String(item.server || "") + "::" + String(item.tool || ""), description: "MCP tool" };
+  }
+  if (item?.type === "dynamicToolCall") {
+    return { kind: "other", target: [item.namespace, item.tool].filter(Boolean).join("::"), description: "tool" };
+  }
+  return { kind: "other", target: String(item?.type || "tool"), description: "" };
+}
+function itemOutput(item) {
+  if (item?.type === "commandExecution") return String(item.aggregatedOutput || "");
+  if (item?.type === "mcpToolCall") return item.error ? String(item.error?.message || JSON.stringify(item.error)) : item.result ? JSON.stringify(item.result) : "";
+  if (item?.type === "dynamicToolCall") return item.contentItems ? JSON.stringify(item.contentItems) : "";
+  return "";
+}
+function parseCodexNotification(method, params, startedAt = /* @__PURE__ */ new Map(), approvalReasons = /* @__PURE__ */ new Map()) {
+  if (method === "hook/started" || method === "hook/completed") {
+    const run2 = params?.run || {};
+    if (run2.eventName !== "preToolUse") return [];
+    const asMs = (value) => {
+      const number = Number(value || 0);
+      return number > 0 && number < 1e11 ? number * 1e3 : number;
+    };
+    const started = asMs(run2.startedAt);
+    const priorStart = Number(approvalReasons.get("__pretool_started__") || 0);
+    if (started && (!priorStart || started < priorStart)) approvalReasons.set("__pretool_started__", String(started));
+    if (method === "hook/completed") {
+      const completed = asMs(run2.completedAt) || started + Number(run2.durationMs || 0);
+      const priorCompleted = Number(approvalReasons.get("__pretool_completed__") || 0);
+      if (completed > priorCompleted) approvalReasons.set("__pretool_completed__", String(completed));
+      const entries = Array.isArray(run2.entries) ? run2.entries : [];
+      const pollEntry = entries.find((entry) => fixPollId(String(entry?.text || "")));
+      const blockingEntry = entries.find((entry) => entry?.kind === "stop" || entry?.kind === "error");
+      const text = String(pollEntry?.text || blockingEntry?.text || run2.statusMessage || "");
+      if (text && (run2.status === "blocked" || run2.status === "failed" || BLOCK_MARKER.test(text))) {
+        approvalReasons.set("__latest_hook__", text);
+        approvalReasons.set("__latest_hook_id__", String(run2.id || "synkro-policy-block"));
+        approvalReasons.set("__latest_hook_duration__", String(Number(run2.durationMs || Math.max(0, completed - started))));
+      }
+    }
+    return [];
+  }
+  if (method === "item/started") {
+    const item = params?.item;
+    if (!item?.id) return [];
+    startedAt.set(String(item.id), Number(params.startedAtMs || Date.now()));
+    if (!["commandExecution", "fileChange", "mcpToolCall", "dynamicToolCall"].includes(item.type)) return [];
+    return [{ type: "tool-start", id: String(item.id), ...itemTarget(item) }];
+  }
+  if (method === "item/completed") {
+    const item = params?.item;
+    if (!item?.id) return [];
+    if (item.type === "hookPrompt") {
+      const text = Array.isArray(item.fragments) ? item.fragments.map((fragment) => String(fragment?.text || "")).filter(Boolean).join("\n") : "";
+      if (text) {
+        const start2 = startedAt.get(String(item.id));
+        const completed2 = Number(params.completedAtMs || Date.now());
+        approvalReasons.set("__latest_hook__", text);
+        approvalReasons.set("__latest_hook_id__", String(item.id));
+        approvalReasons.set("__latest_hook_duration__", String(start2 === void 0 ? 0 : Math.max(0, completed2 - start2)));
+      }
+      startedAt.delete(String(item.id));
+      return [];
+    }
+    if (item.type === "agentMessage") {
+      return item.text ? [{ type: "assistant-message", text: String(item.text) }] : [];
+    }
+    if (item.type === "reasoning") {
+      const text = [...item.summary || [], ...item.content || []].join(" ").trim();
+      return text ? [{ type: "thinking", text }] : [];
+    }
+    if (!["commandExecution", "fileChange", "mcpToolCall", "dynamicToolCall"].includes(item.type)) return [];
+    const output = itemOutput(item);
+    const approvalReason = approvalReasons.get(String(item.id)) || "";
+    const hookReason = approvalReasons.get("__latest_hook__") || "";
+    const rawReason = [approvalReason, hookReason, output].filter(Boolean).join("\n");
+    const status = String(item.status || "");
+    const blocked = BLOCK_MARKER.test(rawReason) || /blocked by PreToolUse hook/i.test(rawReason) || Boolean(hookReason) && (status === "failed" || status === "declined");
+    const itemStart = startedAt.get(String(item.id));
+    const hookStart = Number(approvalReasons.get("__pretool_started__") || 0);
+    const start = itemStart === void 0 ? hookStart || void 0 : hookStart ? Math.min(itemStart, hookStart) : itemStart;
+    const completed = Number(params.completedAtMs || Date.now());
+    const durationMs = start === void 0 ? item.durationMs ?? null : Math.max(0, completed - start);
+    startedAt.delete(String(item.id));
+    approvalReasons.delete(String(item.id));
+    approvalReasons.delete("__latest_hook__");
+    approvalReasons.delete("__latest_hook_id__");
+    approvalReasons.delete("__latest_hook_duration__");
+    approvalReasons.delete("__pretool_started__");
+    approvalReasons.delete("__pretool_completed__");
+    return [{
+      type: "tool-end",
+      id: String(item.id),
+      ...itemTarget(item),
+      ok: status === "completed" && Number(item.exitCode ?? 0) === 0,
+      blocked,
+      reason: blocked ? blockReason(rawReason) : "",
+      pollId: blocked ? fixPollId(rawReason) : "",
+      exitCode: item.exitCode === null || item.exitCode === void 0 ? null : Number(item.exitCode),
+      output: blocked ? "" : output,
+      durationMs
+    }];
+  }
+  if (method === "turn/completed") {
+    const status = String(params?.turn?.status || "failed");
+    const hookReason = approvalReasons.get("__latest_hook__") || "";
+    const events = [];
+    if (hookReason) {
+      events.push({
+        type: "tool-end",
+        id: approvalReasons.get("__latest_hook_id__") || "synkro-policy-block",
+        kind: "other",
+        target: "policy check",
+        ok: false,
+        blocked: true,
+        reason: blockReason(hookReason),
+        pollId: fixPollId(hookReason),
+        exitCode: null,
+        output: "",
+        durationMs: Number(approvalReasons.get("__latest_hook_duration__") || 0)
+      });
+      approvalReasons.delete("__latest_hook__");
+      approvalReasons.delete("__latest_hook_id__");
+      approvalReasons.delete("__latest_hook_duration__");
+    }
+    approvalReasons.delete("__pretool_started__");
+    approvalReasons.delete("__pretool_completed__");
+    events.push({ type: "turn-end", ok: status === "completed", text: String(params?.turn?.error?.message || "") });
+    return events;
+  }
+  return [];
+}
+function codexStderrNotice(raw, initialized) {
+  const text = String(raw || "").trim();
+  if (!text || initialized) return "";
+  return /fatal|panic|authentication failed|not logged in/i.test(text) ? text.split("\n")[0].slice(0, 300) : "";
+}
+async function askApproval(text) {
+  const input = process.stdin;
+  const output = process.stdout;
+  if (!input.isTTY || !output.isTTY) return false;
+  output.write("\n" + S2.rule + "  Synkro approval required" + S2.reset + "\n  " + text.replace(/[\u0000-\u001F\u007F-\u009F]/g, " ").slice(0, 600) + "\n");
+  output.write(S2.dim + "  Press y to allow once; any other key denies." + S2.reset + "\n");
+  return new Promise((resolve8) => {
+    const wasRaw = Boolean(input.isRaw);
+    const onData = (chunk) => {
+      input.off("data", onData);
+      if (input.setRawMode) input.setRawMode(wasRaw);
+      resolve8(chunk.toString("utf8").toLowerCase() === "y");
+    };
+    if (input.setRawMode) input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+  });
+}
+async function runCodexTurn(opts) {
+  const session = new CodexAppSession();
+  try {
+    return await session.turn(opts);
+  } finally {
+    session.close();
+  }
+}
+var CodexAppSession;
+var init_codex = __esm({
+  "cli/harness/codex.ts"() {
+    "use strict";
+    init_composer();
+    init_events();
+    init_run();
+    init_render2();
+    CodexAppSession = class {
+      child = null;
+      buffer = "";
+      nextId = 1;
+      pending = /* @__PURE__ */ new Map();
+      initialized = false;
+      threadId = "";
+      model = "Codex";
+      cwd = "";
+      active = null;
+      send(message) {
+        this.child?.stdin.write(JSON.stringify({ jsonrpc: "2.0", ...message }) + "\n");
+      }
+      request(method, params) {
+        const id = this.nextId++;
+        return new Promise((resolve8, reject) => {
+          this.pending.set(id, { resolve: resolve8, reject });
+          this.send({ id, method, params });
+        });
+      }
+      respond(id, result) {
+        this.send({ id, result });
+      }
+      async handleServerRequest(message) {
+        const method = String(message.method || "");
+        const params = message.params || {};
+        if (params.itemId && params.reason) this.active?.approvalReasons.set(String(params.itemId), String(params.reason));
+        if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
+          const summary = String(params.reason || params.command || params.grantRoot || "Allow this action?");
+          const accepted = await askApproval(summary);
+          this.respond(message.id, { decision: accepted ? "accept" : "decline" });
+          return;
+        }
+        if (method === "item/tool/requestUserInput") {
+          const answers = {};
+          for (const question of params.questions || []) answers[String(question.id)] = { answers: [] };
+          this.respond(message.id, { answers });
+          return;
+        }
+        if (method === "mcpServer/elicitation/request") {
+          this.respond(message.id, { action: "decline" });
+          return;
+        }
+        this.respond(message.id, {});
+      }
+      handleLine(line) {
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          return;
+        }
+        if (message.method && message.id !== void 0) {
+          void this.handleServerRequest(message);
+          return;
+        }
+        if (message.method) {
+          const active = this.active;
+          if (!active) return;
+          const events = parseCodexNotification(message.method, message.params, active.startedAt, active.approvalReasons);
+          for (const event of events) active.sink.event(event);
+          if (message.method === "turn/started") active.turnId = String(message.params?.turn?.id || "");
+          if (message.method === "turn/completed") {
+            const result = active.sink.finish(message.params?.turn?.status === "completed" ? 0 : 1, active.interrupted);
+            this.active = null;
+            active.resolve(result);
+          }
+          return;
+        }
+        if (message.id !== void 0) {
+          const pending = this.pending.get(Number(message.id));
+          if (!pending) return;
+          this.pending.delete(Number(message.id));
+          if (message.error) pending.reject(new Error(String(message.error?.message || JSON.stringify(message.error))));
+          else pending.resolve(message.result);
+        }
+      }
+      async start(cwd) {
+        if (this.child) return;
+        this.cwd = cwd;
+        this.child = spawn10("codex", ["app-server"], { cwd, stdio: ["pipe", "pipe", "pipe"] });
+        this.child.stdout.on("data", (chunk) => {
+          this.buffer += chunk.toString("utf8");
+          let newline = this.buffer.indexOf("\n");
+          while (newline !== -1) {
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (line) this.handleLine(line);
+            newline = this.buffer.indexOf("\n");
+          }
+        });
+        this.child.stderr.on("data", (chunk) => {
+          const note = codexStderrNotice(chunk.toString("utf8"), this.initialized);
+          if (note) this.active?.sink.notice(note);
+        });
+        this.child.on("close", (code) => {
+          const active = this.active;
+          if (active) {
+            this.active = null;
+            active.resolve(active.sink.finish(code ?? 1, active.interrupted));
+          }
+          for (const pending of this.pending.values()) pending.reject(new Error("codex app-server exited"));
+          this.pending.clear();
+          this.child = null;
+        });
+        this.child.on("error", (error) => {
+          const failure = new Error("failed to start codex app-server: " + String(error));
+          const active = this.active;
+          if (active) {
+            active.sink.notice(failure.message);
+            this.active = null;
+            active.resolve(active.sink.finish(1, active.interrupted));
+          }
+          for (const pending of this.pending.values()) pending.reject(failure);
+          this.pending.clear();
+        });
+        const initialized = await this.request("initialize", { clientInfo: { name: "synkro-governed", version: "1.0.0" } });
+        this.initialized = true;
+        this.send({ method: "initialized", params: {} });
+        const started = await this.request("thread/start", {
+          cwd,
+          approvalPolicy: "on-request",
+          approvalsReviewer: "user",
+          sandbox: "workspace-write",
+          ephemeral: false
+        });
+        this.threadId = String(started?.thread?.id || "");
+        this.model = String(started?.model || initialized?.userAgent || "Codex");
+        if (!this.threadId) throw new Error("codex app-server did not return a thread id");
+      }
+      async turn(opts) {
+        await this.start(opts.cwd);
+        if (this.active) throw new Error("a Codex turn is already running");
+        const sink = createTurnSink({
+          write: opts.write || ((text) => process.stdout.write(text)),
+          onEvent: opts.onEvent,
+          width: opts.width || Number(process.stdout.columns || 100),
+          animate: false,
+          showPrompt: opts.showPrompt,
+          showHeader: opts.showHeader
+        });
+        sink.event({ type: "session-start", sessionId: this.threadId, model: this.model, cwd: this.cwd, authSource: "login" });
+        sink.event({
+          type: "user-message",
+          text: opts.prompt || (opts.images?.length ? "[" + opts.images.length + " image attached]" : "")
+        });
+        const result = new Promise((resolve8) => {
+          this.active = { sink, resolve: resolve8, startedAt: /* @__PURE__ */ new Map(), approvalReasons: /* @__PURE__ */ new Map(), turnId: "", interrupted: false };
+        });
+        const onAbort = () => {
+          if (!this.active) return;
+          this.active.interrupted = true;
+          if (this.active.turnId) void this.request("turn/interrupt", { threadId: this.threadId, turnId: this.active.turnId }).catch(() => {
+          });
+        };
+        if (opts.signal?.aborted) onAbort();
+        else opts.signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+          await this.request("turn/start", {
+            threadId: this.threadId,
+            cwd: opts.cwd,
+            input: codexUserInput({ text: opts.prompt, images: opts.images || [] })
+          });
+          return await result;
+        } finally {
+          opts.signal?.removeEventListener("abort", onAbort);
+        }
+      }
+      close() {
+        this.child?.kill();
+        this.child = null;
+      }
+    };
+  }
+});
+
+// cli/harness/fixPoll.ts
+function pollBaseUrl() {
+  const port = String(process.env.SYNKRO_MCP_PORT || "18931");
+  return "http://127.0.0.1:" + port + "/api/local/fix-poll";
+}
+function neutralizeTerminalControls(value) {
+  return value.replace(/[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u001B]/g, "");
+}
+async function loadFixPoll(itemId, fetchImpl = fetch) {
+  const response = await fetchImpl(pollBaseUrl() + "?item_id=" + encodeURIComponent(itemId));
+  if (!response.ok) return null;
+  const body = await response.json();
+  const candidates = Array.isArray(body.candidates) ? body.candidates.filter((candidate) => typeof candidate === "string").slice(0, 8) : [];
+  if (!candidates.length || body.status !== "pending") return null;
+  return {
+    itemId,
+    filePath: String(body.file_path || ""),
+    ruleId: String(body.rule_id || ""),
+    candidates
+  };
+}
+async function recordFixPoll(itemId, chosenIdx, fetchImpl = fetch) {
+  const response = await fetchImpl(pollBaseUrl() + "/record", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ item_id: itemId, chosen_idx: chosenIdx })
+  });
+  return response.ok;
+}
+function fixPollLines(poll, selected, width = 100) {
+  const max = Math.max(32, width - 10);
+  const choices = [...poll.candidates, "None of the above"];
+  const scope = [poll.ruleId, poll.filePath].filter(Boolean).join("  \xB7  ");
+  const lines = [
+    "",
+    S2.bold + S2.rule + "  Synkro needs your decision" + S2.reset,
+    ...scope ? [S2.dim + "  " + neutralizeTerminalControls(scope) + S2.reset] : [],
+    ""
+  ];
+  choices.forEach((choice, index) => {
+    const prefix = index === selected ? S2.user + "  \u276F " : S2.dim + "    ";
+    const text = wrap(index + 1 + ". " + neutralizeTerminalControls(choice), max);
+    lines.push(prefix + (text[0] || "") + S2.reset);
+    for (const continuation of text.slice(1)) lines.push("      " + continuation);
+  });
+  lines.push("", S2.dim + "  \u2191/\u2193 select  \xB7  Enter confirm  \xB7  1-" + choices.length + " choose" + S2.reset);
+  return lines;
+}
+async function pickFixPoll(poll, io = {}) {
+  const input = io.input || process.stdin;
+  const output = io.output || process.stdout;
+  if (!input.isTTY || !output.isTTY) return -1;
+  let selected = 0;
+  let rendered = 0;
+  const draw = () => {
+    if (rendered) output.write("\x1B[" + rendered + "A\x1B[J");
+    const lines = fixPollLines(poll, selected, Number(output.columns || 100));
+    output.write(lines.join("\n") + "\n");
+    rendered = lines.length;
+  };
+  const choice = await new Promise((resolve8) => {
+    const choices = poll.candidates.length + 1;
+    const wasRaw = Boolean(input.isRaw);
+    const done = (index) => {
+      input.off("data", onData);
+      if (input.setRawMode) input.setRawMode(wasRaw);
+      resolve8(index === poll.candidates.length ? -1 : index);
+    };
+    const onData = (chunk) => {
+      const key = chunk.toString("utf8");
+      if (key === "") return done(poll.candidates.length);
+      if (key === "\x1B" || key.toLowerCase() === "n") return done(poll.candidates.length);
+      if (key === "\r" || key === "\n") return done(selected);
+      if (key === "\x1B[A" || key === "k") selected = (selected - 1 + choices) % choices;
+      else if (key === "\x1B[B" || key === "j") selected = (selected + 1) % choices;
+      else if (/^[1-9]$/.test(key)) {
+        const index = Number(key) - 1;
+        if (index < choices) return done(index);
+      } else return;
+      draw();
+    };
+    if (input.setRawMode) input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+    draw();
+  });
+  return choice;
+}
+async function resolveFixPolls(events, io = {}) {
+  const ids = Array.from(new Set(events.filter((event) => event.type === "tool-end").map((event) => event.pollId || "").filter(Boolean)));
+  const recorded = [];
+  for (const itemId of ids) {
+    const poll = await loadFixPoll(itemId, io.fetchImpl).catch(() => null);
+    if (!poll) continue;
+    const chosen = await pickFixPoll(poll, io);
+    const ok = await recordFixPoll(itemId, chosen, io.fetchImpl).catch(() => false);
+    if (ok) recorded.push(chosen);
+    else (io.output || process.stdout).write(S2.blocked + "  Could not record that Synkro decision.\n" + S2.reset);
+  }
+  return recorded;
+}
+var init_fixPoll = __esm({
+  "cli/harness/fixPoll.ts"() {
+    "use strict";
+    init_render2();
+  }
+});
+
 // cli/harness/identity.ts
-import { execFileSync as execFileSync5 } from "child_process";
-import { homedir as homedir38 } from "os";
-function shortenPath(path, home = homedir38()) {
+import { execFileSync as execFileSync6 } from "child_process";
+import { homedir as homedir39 } from "os";
+function shortenPath(path, home = homedir39()) {
   const value = String(path || "");
   if (home && value === home) return "~";
   if (home && value.startsWith(home + "/")) return "~" + value.slice(home.length);
@@ -17361,7 +18188,7 @@ function parseCursorAccount(output) {
 }
 function cursorAccount() {
   try {
-    const out = execFileSync5("cursor-agent", ["status"], {
+    const out = execFileSync6("cursor-agent", ["status"], {
       encoding: "utf8",
       timeout: 5e3,
       stdio: ["ignore", "pipe", "pipe"]
@@ -17412,13 +18239,13 @@ var init_identity2 = __esm({
 });
 
 // cli/harness/session.ts
-import { createInterface as createInterface5 } from "readline";
 async function runOnce(harness, cwd, prompt, echoPrompt = true, showHeader = true, signal) {
-  if (harness !== "cursor") {
+  if (harness !== "cursor" && harness !== "codex") {
     process.stdout.write(S2.dim + "  " + harness + " sessions are not embedded yet\n" + S2.reset);
     return 1;
   }
-  const result = await runCursorTurn({ prompt, cwd, showPrompt: echoPrompt, showHeader, signal });
+  const result = harness === "codex" ? await runCodexTurn({ prompt, cwd, showPrompt: echoPrompt, showHeader, signal }) : await runCursorTurn({ prompt, cwd, showPrompt: echoPrompt, showHeader, signal });
+  await resolveFixPolls(result.events);
   if (result.blocked > 0) {
     process.stdout.write(
       S2.blocked + "  " + result.blocked + " action" + (result.blocked === 1 ? "" : "s") + " blocked by policy" + S2.reset + "\n"
@@ -17429,43 +18256,49 @@ async function runOnce(harness, cwd, prompt, echoPrompt = true, showHeader = tru
 async function runGovernedSession(harness, cwd, prompt) {
   if (prompt) return runOnce(harness, cwd, prompt);
   process.stdout.write(identityHeader({ cwd, harness, identity: readIdentity(harness) }).join("\n") + "\n");
-  const rl = createInterface5({ input: process.stdin, output: process.stdout });
-  const ask3 = () => new Promise((resolve7) => {
-    const onClose = () => resolve7(null);
-    rl.once("close", onClose);
-    rl.question(S2.user + "  \u276F " + S2.reset, (answer) => {
-      rl.removeListener("close", onClose);
-      resolve7(answer);
-    });
-  });
+  const codex = harness === "codex" ? new CodexAppSession() : null;
   let turn = null;
-  rl.on("SIGINT", () => {
-    if (turn) {
-      turn.abort();
-      return;
-    }
-    process.stdout.write("\n");
-    rl.close();
-  });
+  const interruptTurn = () => {
+    turn?.abort();
+  };
+  process.on("SIGINT", interruptTurn);
   let first = true;
-  for (; ; ) {
-    const answer = await ask3();
-    if (answer === null) break;
-    const line = answer.trim();
-    if (!line) continue;
-    if (line === "exit" || line === "quit") break;
-    turn = new AbortController();
-    await runOnce(harness, cwd, line, false, first, turn.signal);
-    turn = null;
-    first = false;
+  try {
+    for (; ; ) {
+      const draft = await readPrompt(cwd);
+      if (draft === null) break;
+      const line = draft.text.trim();
+      if (!line && draft.images.length === 0) continue;
+      if (draft.images.length === 0 && (line === "exit" || line === "quit")) break;
+      try {
+        turn = new AbortController();
+        const cursorPrompt = draft.images.length ? [draft.text, "", "Attached image files:", ...draft.images].join("\n") : draft.text;
+        const result = codex ? await codex.turn({ prompt: draft.text, images: draft.images, cwd, showPrompt: false, showHeader: first, signal: turn.signal }) : await runCursorTurn({ prompt: cursorPrompt, cwd, showPrompt: false, showHeader: first, signal: turn.signal });
+        await resolveFixPolls(result.events);
+        if (result.blocked > 0) {
+          process.stdout.write(
+            S2.blocked + "  " + result.blocked + " action" + (result.blocked === 1 ? "" : "s") + " blocked by policy" + S2.reset + "\n"
+          );
+        }
+        first = false;
+      } finally {
+        cleanupPromptDraft(draft);
+        turn = null;
+      }
+    }
+  } finally {
+    process.off("SIGINT", interruptTurn);
+    codex?.close();
   }
-  rl.close();
   return 0;
 }
 var init_session = __esm({
   "cli/harness/session.ts"() {
     "use strict";
+    init_composer();
     init_run();
+    init_codex();
+    init_fixPoll();
     init_identity2();
     init_render2();
   }
@@ -17489,7 +18322,7 @@ async function takeover(kind, cwd) {
   const harness = ["claude", "codex", "cursor"].includes(kind) ? kind : "claude";
   const info = await detectContainerBackend();
   const reachable = info.backend === "container" ? (await run(info.runner, ["test", "-d", cwd])).ok : false;
-  const backend = reachable ? "container" : "host";
+  const backend = harness === "codex" ? "host" : reachable ? "container" : "host";
   const spaceName = cwd.split("/").filter(Boolean).pop() || "space";
   const spawned = await spawnAgent(info, {
     name: spaceName + "-" + harness + "-" + String(process.pid % 1e4),
@@ -17517,7 +18350,7 @@ async function restoreSession(session) {
     harness: record.harness,
     spaceName: record.spaceName,
     cwd: record.space,
-    backend: record.backend,
+    backend: record.harness === "codex" ? "host" : record.backend,
     resume: true
   });
 }
@@ -17660,11 +18493,11 @@ __export(linear_exports, {
   linearCommand: () => linearCommand
 });
 import { readFileSync as readFileSync33 } from "fs";
-import { homedir as homedir39 } from "os";
-import { join as join37 } from "path";
+import { homedir as homedir40 } from "os";
+import { join as join38 } from "path";
 function mcpJwt() {
   try {
-    return readFileSync33(join37(SYNKRO_DIR14, ".mcp-jwt"), "utf-8").trim();
+    return readFileSync33(join38(SYNKRO_DIR14, ".mcp-jwt"), "utf-8").trim();
   } catch {
     return "";
   }
@@ -17703,7 +18536,7 @@ var SYNKRO_DIR14, PORT2, BASE;
 var init_linear = __esm({
   "cli/commands/linear.ts"() {
     "use strict";
-    SYNKRO_DIR14 = join37(homedir39(), ".synkro");
+    SYNKRO_DIR14 = join38(homedir40(), ".synkro");
     PORT2 = process.env.SYNKRO_MCP_PORT || "18931";
     BASE = `http://127.0.0.1:${PORT2}`;
   }
@@ -17852,10 +18685,10 @@ var init_cveReachability = __esm({
 });
 
 // cli/reachability/reachabilityScan.ts
-import { spawnSync as spawnSync12, execFileSync as execFileSync6 } from "child_process";
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync27, existsSync as existsSync38, readdirSync as readdirSync10 } from "fs";
-import { join as join38 } from "path";
-import { homedir as homedir40 } from "os";
+import { spawnSync as spawnSync13, execFileSync as execFileSync7 } from "child_process";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync28, existsSync as existsSync39, readdirSync as readdirSync10 } from "fs";
+import { join as join39 } from "path";
+import { homedir as homedir41 } from "os";
 import { createRequire } from "module";
 function walkSourceFiles(repoRoot3, maxFiles = 4e3, maxBytes = 5e5) {
   const SKIP2 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage", ".next", ".turbo", "out", ".cache", ".synkro", ".claude", "vendor", "__tests__", "test-results"]);
@@ -17872,7 +18705,7 @@ function walkSourceFiles(repoRoot3, maxFiles = 4e3, maxBytes = 5e5) {
     }
     for (const e of ents) {
       if (files.length >= maxFiles) break;
-      const full = join38(dir, e.name);
+      const full = join39(dir, e.name);
       if (e.isDirectory()) {
         if (!SKIP2.has(e.name) && !e.name.startsWith(".")) stack.push(full);
         continue;
@@ -17899,12 +18732,12 @@ function cleanVersion(spec) {
 function gatherManifestVersions(repoRoot3) {
   const out = {};
   const dirs = [repoRoot3];
-  const pkgsDir = join38(repoRoot3, "packages");
-  if (existsSync38(pkgsDir)) {
+  const pkgsDir = join39(repoRoot3, "packages");
+  if (existsSync39(pkgsDir)) {
     try {
       for (const d of readdirSync10(pkgsDir)) {
-        const pd = join38(pkgsDir, d);
-        if (existsSync38(join38(pd, "package.json"))) dirs.push(pd);
+        const pd = join39(pkgsDir, d);
+        if (existsSync39(join39(pd, "package.json"))) dirs.push(pd);
       }
     } catch {
     }
@@ -17913,7 +18746,7 @@ function gatherManifestVersions(repoRoot3) {
   for (const dir of dirs) {
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync35(join38(dir, "package.json"), "utf8"));
+      pkg = JSON.parse(readFileSync35(join39(dir, "package.json"), "utf8"));
     } catch {
       continue;
     }
@@ -17936,25 +18769,25 @@ function findJelly(repoRoot3) {
     const pkg = JSON.parse(readFileSync35(pkgJson, "utf8"));
     const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin && (pkg.bin.jelly || pkg.bin[Object.keys(pkg.bin)[0]]);
     if (bin) {
-      const p = join38(dir, bin);
-      if (existsSync38(p)) return p;
+      const p = join39(dir, bin);
+      if (existsSync39(p)) return p;
     }
   } catch {
   }
   for (const base of [repoRoot3, process.cwd()]) {
-    const b = join38(base, "node_modules", ".bin", "jelly");
-    if (existsSync38(b)) return b;
+    const b = join39(base, "node_modules", ".bin", "jelly");
+    if (existsSync39(b)) return b;
   }
   return null;
 }
 function findEntries(repoRoot3) {
   const dirs = [repoRoot3];
-  const pkgsDir = join38(repoRoot3, "packages");
-  if (existsSync38(pkgsDir)) {
+  const pkgsDir = join39(repoRoot3, "packages");
+  if (existsSync39(pkgsDir)) {
     try {
       for (const d of readdirSync10(pkgsDir)) {
-        const pd = join38(pkgsDir, d);
-        if (existsSync38(join38(pd, "package.json"))) dirs.push(pd);
+        const pd = join39(pkgsDir, d);
+        if (existsSync39(join39(pd, "package.json"))) dirs.push(pd);
       }
     } catch {
     }
@@ -17962,12 +18795,12 @@ function findEntries(repoRoot3) {
   const entries = [];
   for (const dir of dirs) {
     try {
-      const pkg = JSON.parse(readFileSync35(join38(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync35(join39(dir, "package.json"), "utf8"));
       const cands = [pkg.source, pkg.module, pkg.main, "src/index.ts", "src/index.js", "src/main.ts", "src/server.ts", "index.ts", "index.js"];
       for (const c of cands) {
         if (typeof c !== "string") continue;
-        const f = join38(dir, c);
-        if (existsSync38(f)) {
+        const f = join39(dir, c);
+        if (existsSync39(f)) {
           entries.push(f);
           break;
         }
@@ -17979,7 +18812,7 @@ function findEntries(repoRoot3) {
 }
 function currentCommit(repoRoot3) {
   try {
-    return execFileSync6("git", ["rev-parse", "HEAD"], { cwd: repoRoot3, encoding: "utf8" }).trim();
+    return execFileSync7("git", ["rev-parse", "HEAD"], { cwd: repoRoot3, encoding: "utf8" }).trim();
   } catch {
     return "";
   }
@@ -18000,7 +18833,7 @@ function parseApiUsage(log) {
 }
 function runReachabilityScan(repoRoot3, opts = {}) {
   const commit = currentCommit(repoRoot3);
-  if (!opts.force && commit && existsSync38(REACHABILITY_PATH)) {
+  if (!opts.force && commit && existsSync39(REACHABILITY_PATH)) {
     try {
       const prev = JSON.parse(readFileSync35(REACHABILITY_PATH, "utf8"));
       if (prev.commit === commit) return { ok: true, cached: true, packages: Object.keys(prev.packages || {}).length };
@@ -18053,7 +18886,7 @@ function runReachabilityScan(repoRoot3, opts = {}) {
   if (jelly) {
     const entries = findEntries(repoRoot3);
     if (entries.length > 0) {
-      const r = spawnSync12(
+      const r = spawnSync13(
         process.execPath,
         [jelly, "-b", repoRoot3, "--api-usage", ...entries],
         { encoding: "utf8", timeout: opts.timeoutMs ?? 18e4, maxBuffer: 2e8 }
@@ -18091,7 +18924,7 @@ function runReachabilityScan(repoRoot3, opts = {}) {
   if (Object.keys(packages).length === 0) return { ok: false, reason: "no package usage found (no jelly output, no AST imports)" };
   const file = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), commit, tool, packages, versions: gatherManifestVersions(repoRoot3) };
   try {
-    writeFileSync27(REACHABILITY_PATH, JSON.stringify(file, null, 2));
+    writeFileSync28(REACHABILITY_PATH, JSON.stringify(file, null, 2));
   } catch (e) {
     return { ok: false, reason: "write failed: " + String(e.message || e) };
   }
@@ -18103,7 +18936,7 @@ var init_reachabilityScan = __esm({
     "use strict";
     init_cveReachability();
     require2 = createRequire(import.meta.url);
-    REACHABILITY_PATH = join38(homedir40(), ".synkro", "reachability.json");
+    REACHABILITY_PATH = join39(homedir41(), ".synkro", "reachability.json");
   }
 });
 
@@ -18112,13 +18945,13 @@ var reachabilityScan_exports = {};
 __export(reachabilityScan_exports, {
   reachabilityScanCommand: () => reachabilityScanCommand
 });
-import { readFileSync as readFileSync36, existsSync as existsSync39 } from "fs";
-import { join as join39 } from "path";
-import { homedir as homedir41 } from "os";
-import { execFileSync as execFileSync7 } from "child_process";
+import { readFileSync as readFileSync36, existsSync as existsSync40 } from "fs";
+import { join as join40 } from "path";
+import { homedir as homedir42 } from "os";
+import { execFileSync as execFileSync8 } from "child_process";
 function readConfigEnv4() {
-  const p = join39(SYNKRO_DIR15, "config.env");
-  if (!existsSync39(p)) return {};
+  const p = join40(SYNKRO_DIR15, "config.env");
+  if (!existsSync40(p)) return {};
   const out = {};
   for (const line of readFileSync36(p, "utf-8").split("\n")) {
     const t = line.trim();
@@ -18130,7 +18963,7 @@ function readConfigEnv4() {
 }
 function repoRoot2() {
   try {
-    return execFileSync7("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" }).trim();
+    return execFileSync8("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" }).trim();
   } catch {
     return process.cwd();
   }
@@ -18138,7 +18971,7 @@ function repoRoot2() {
 function repoSlug(root) {
   const run2 = (a) => {
     try {
-      return execFileSync7("git", a, { encoding: "utf-8" }).trim();
+      return execFileSync8("git", a, { encoding: "utf-8" }).trim();
     } catch {
       return "";
     }
@@ -18152,10 +18985,10 @@ async function pushToCloud(cfg, repo) {
   while (gwBase.endsWith("/")) gwBase = gwBase.slice(0, -1);
   let jwt2 = "";
   try {
-    jwt2 = readFileSync36(join39(SYNKRO_DIR15, ".mcp-jwt"), "utf-8").trim();
+    jwt2 = readFileSync36(join40(SYNKRO_DIR15, ".mcp-jwt"), "utf-8").trim();
   } catch {
   }
-  if (!jwt2 || !existsSync39(REACHABILITY_PATH)) return;
+  if (!jwt2 || !existsSync40(REACHABILITY_PATH)) return;
   const body = readFileSync36(REACHABILITY_PATH, "utf-8");
   try {
     const resp = await fetch(gwBase + "/api/v1/reachability?repo=" + encodeURIComponent(repo), {
@@ -18188,7 +19021,7 @@ var init_reachabilityScan2 = __esm({
   "cli/commands/reachabilityScan.ts"() {
     "use strict";
     init_reachabilityScan();
-    SYNKRO_DIR15 = join39(homedir41(), ".synkro");
+    SYNKRO_DIR15 = join40(homedir42(), ".synkro");
   }
 });
 
@@ -18318,11 +19151,11 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { readFileSync as readFileSync37, writeFileSync as writeFileSync28, existsSync as existsSync40 } from "fs";
-import { join as join40 } from "path";
-import { homedir as homedir42 } from "os";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync29, existsSync as existsSync41 } from "fs";
+import { join as join41 } from "path";
+import { homedir as homedir43 } from "os";
 function readConfigEnv5() {
-  if (!existsSync40(CONFIG_PATH9)) return {};
+  if (!existsSync41(CONFIG_PATH9)) return {};
   const out = {};
   for (const line of readFileSync37(CONFIG_PATH9, "utf-8").split("\n")) {
     const t = line.trim();
@@ -18333,7 +19166,7 @@ function readConfigEnv5() {
   return out;
 }
 function updateConfigValue(key, value) {
-  if (!existsSync40(CONFIG_PATH9)) {
+  if (!existsSync41(CONFIG_PATH9)) {
     console.error("No config found. Run `synkro install` first.");
     process.exit(1);
   }
@@ -18348,7 +19181,7 @@ function updateConfigValue(key, value) {
     return line;
   });
   if (!found) updated.splice(updated.length - 1, 0, `${key}='${value}'`);
-  writeFileSync28(CONFIG_PATH9, updated.join("\n"), "utf-8");
+  writeFileSync29(CONFIG_PATH9, updated.join("\n"), "utf-8");
 }
 function resolveInferenceMode(cfg) {
   if ((cfg.SYNKRO_GRADING_MODE || "local") === "byok") return "byok";
@@ -18506,8 +19339,8 @@ var init_config = __esm({
     "use strict";
     init_stub();
     init_optout();
-    SYNKRO_DIR16 = join40(homedir42(), ".synkro");
-    CONFIG_PATH9 = join40(SYNKRO_DIR16, "config.env");
+    SYNKRO_DIR16 = join41(homedir43(), ".synkro");
+    CONFIG_PATH9 = join41(SYNKRO_DIR16, "config.env");
   }
 });
 
@@ -18597,12 +19430,12 @@ async function runExport(args2) {
 }
 function confirmYesNo(question) {
   if (!process.stdin.isTTY) return Promise.resolve(false);
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const rl = createInterface6({ input: process.stdin, output: process.stdout });
     rl.question(`${question} (y/N): `, (answer) => {
       rl.close();
       const t = answer.trim().toLowerCase();
-      resolve7(t === "y" || t === "yes");
+      resolve8(t === "y" || t === "yes");
     });
   });
 }
@@ -18697,11 +19530,11 @@ Usage:
 
 // cli/inventory/identity.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync41, mkdirSync as mkdirSync24, readFileSync as readFileSync38, renameSync as renameSync9, writeFileSync as writeFileSync29 } from "fs";
-import { homedir as homedir43 } from "os";
-import { dirname as dirname12, join as join41 } from "path";
+import { existsSync as existsSync42, mkdirSync as mkdirSync24, readFileSync as readFileSync38, renameSync as renameSync9, writeFileSync as writeFileSync30 } from "fs";
+import { homedir as homedir44 } from "os";
+import { dirname as dirname13, join as join42 } from "path";
 function operationalIdentityPath() {
-  return process.env.SYNKRO_OPERATIONAL_IDENTITY_PATH || join41(homedir43(), ".synkro", "installation.json");
+  return process.env.SYNKRO_OPERATIONAL_IDENTITY_PATH || join42(homedir44(), ".synkro", "installation.json");
 }
 function validIdentity(value) {
   if (!value || typeof value !== "object") return false;
@@ -18709,15 +19542,15 @@ function validIdentity(value) {
   return typeof row2.installation_id === "string" && UUID_RE.test(row2.installation_id) && typeof row2.created_at === "string" && Number.isFinite(Date.parse(row2.created_at));
 }
 function writeIdentity(path, identity) {
-  mkdirSync24(dirname12(path), { recursive: true, mode: 448 });
+  mkdirSync24(dirname13(path), { recursive: true, mode: 448 });
   const temp = `${path}.${process.pid}.${randomUUID5()}.tmp`;
-  writeFileSync29(temp, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  writeFileSync30(temp, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf8", mode: 384 });
   renameSync9(temp, path);
 }
 function getOperationalInstallationIdentity(path = operationalIdentityPath()) {
   const prior = cached4.get(path);
   if (prior) return prior;
-  if (existsSync41(path)) {
+  if (existsSync42(path)) {
     try {
       const parsed = JSON.parse(readFileSync38(path, "utf8"));
       if (validIdentity(parsed)) {
@@ -18744,13 +19577,13 @@ var init_identity3 = __esm({
 // cli/inventory/collector.ts
 import { createHash as createHash5 } from "crypto";
 import {
-  existsSync as existsSync42,
+  existsSync as existsSync43,
   readFileSync as readFileSync39,
   readdirSync as readdirSync11,
-  statSync as statSync5
+  statSync as statSync6
 } from "fs";
-import { arch, homedir as homedir44, hostname as hostname2, platform as platform6, release as release2 } from "os";
-import { basename as basename3, join as join42, relative, resolve as resolve5 } from "path";
+import { arch, homedir as homedir45, hostname as hostname2, platform as platform6, release as release2 } from "os";
+import { basename as basename4, join as join43, relative, resolve as resolve6 } from "path";
 import { fileURLToPath } from "url";
 function sha256(value) {
   return createHash5("sha256").update(value).digest("hex");
@@ -18760,14 +19593,14 @@ function pseudonymousHostnameHash(installationId, host) {
 }
 function cliVersion() {
   try {
-    return "1.10.6";
+    return "1.10.8";
   } catch {
     return "0.0.0";
   }
 }
 function readJson(path) {
   try {
-    if (!existsSync42(path)) return null;
+    if (!existsSync43(path)) return null;
     const parsed = JSON.parse(readFileSync39(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
@@ -18776,7 +19609,7 @@ function readJson(path) {
 }
 function readText(path) {
   try {
-    if (!existsSync42(path)) return "";
+    if (!existsSync43(path)) return "";
     return readFileSync39(path, "utf8");
   } catch {
     return "";
@@ -18797,7 +19630,7 @@ function canonical(raw) {
 }
 function safePackageName(command, args2) {
   if (typeof command !== "string" || !command.trim()) return void 0;
-  const runner = basename3(command.trim()).replace(/\.exe$/i, "");
+  const runner = basename4(command.trim()).replace(/\.exe$/i, "");
   if (Array.isArray(args2) && ["npx", "bunx", "uvx"].includes(runner)) {
     const pkg = args2.find((arg) => typeof arg === "string" && !arg.startsWith("-"));
     if (typeof pkg === "string") {
@@ -18805,7 +19638,7 @@ function safePackageName(command, args2) {
       if (/^(?:@[a-z0-9_.-]+\/)?[a-z0-9_.-]+(?:@[a-z0-9_.+~-]+)?$/i.test(candidate)) {
         return candidate;
       }
-      return basename3(candidate);
+      return basename4(candidate);
     }
   }
   return runner;
@@ -18863,16 +19696,16 @@ function mcpArtifactsFromJson(harness, config, configScope = "user") {
 }
 function claudeDesktopConfigCandidates(home, targetPlatform) {
   if (targetPlatform === "darwin") {
-    return [join42(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")];
+    return [join43(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")];
   }
   if (targetPlatform === "linux") {
     return [
-      join42(home, ".config", "Claude", "claude_desktop_config.json"),
-      join42(home, ".config", "claude", "claude_desktop_config.json")
+      join43(home, ".config", "Claude", "claude_desktop_config.json"),
+      join43(home, ".config", "claude", "claude_desktop_config.json")
     ];
   }
   if (targetPlatform === "win32" && process.env.APPDATA) {
-    return [join42(process.env.APPDATA, "Claude", "claude_desktop_config.json")];
+    return [join43(process.env.APPDATA, "Claude", "claude_desktop_config.json")];
   }
   return [];
 }
@@ -18880,7 +19713,7 @@ function claudeManagedMcpConfigCandidates(targetPlatform) {
   if (targetPlatform === "darwin") return ["/Library/Application Support/ClaudeCode/managed-mcp.json"];
   if (targetPlatform === "linux") return ["/etc/claude-code/managed-mcp.json"];
   if (targetPlatform === "win32" && process.env.ProgramFiles) {
-    return [join42(process.env.ProgramFiles, "ClaudeCode", "managed-mcp.json")];
+    return [join43(process.env.ProgramFiles, "ClaudeCode", "managed-mcp.json")];
   }
   return [];
 }
@@ -18888,8 +19721,8 @@ function discoveredProjectRoots(claudeState, currentDirectory, explicit = [], cu
   const roots = /* @__PURE__ */ new Set();
   const add = (value) => {
     if (typeof value !== "string" || !value.trim()) return;
-    const path = resolve5(value);
-    if (existsSync42(path)) roots.add(path);
+    const path = resolve6(value);
+    if (existsSync43(path)) roots.add(path);
   };
   add(currentDirectory);
   for (const path of explicit) add(path);
@@ -18900,17 +19733,17 @@ function discoveredProjectRoots(claudeState, currentDirectory, explicit = [], cu
   return [...roots];
 }
 function cursorWorkspaceStorageCandidates(home, targetPlatform) {
-  if (targetPlatform === "darwin") return [join42(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage")];
-  if (targetPlatform === "linux") return [join42(home, ".config", "Cursor", "User", "workspaceStorage")];
+  if (targetPlatform === "darwin") return [join43(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage")];
+  if (targetPlatform === "linux") return [join43(home, ".config", "Cursor", "User", "workspaceStorage")];
   if (targetPlatform === "win32" && process.env.APPDATA) {
-    return [join42(process.env.APPDATA, "Cursor", "User", "workspaceStorage")];
+    return [join43(process.env.APPDATA, "Cursor", "User", "workspaceStorage")];
   }
   return [];
 }
 function cursorWorkspaceRoots(home, targetPlatform) {
   const roots = /* @__PURE__ */ new Set();
   for (const storage of cursorWorkspaceStorageCandidates(home, targetPlatform)) {
-    if (!existsSync42(storage)) continue;
+    if (!existsSync43(storage)) continue;
     let entries = [];
     try {
       entries = readdirSync11(storage, { withFileTypes: true });
@@ -18919,12 +19752,12 @@ function cursorWorkspaceRoots(home, targetPlatform) {
     }
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.isSymbolicLink?.()) continue;
-      const state = readJson(join42(storage, entry.name, "workspace.json"));
+      const state = readJson(join43(storage, entry.name, "workspace.json"));
       const raw = state?.folder;
       if (typeof raw !== "string" || !raw.trim()) continue;
       try {
         const path = raw.startsWith("file:") ? fileURLToPath(raw) : raw;
-        if (existsSync42(path)) roots.add(resolve5(path));
+        if (existsSync43(path)) roots.add(resolve6(path));
       } catch {
       }
     }
@@ -19000,10 +19833,10 @@ function hookArtifacts(harness, config) {
         harness,
         type: "hook",
         canonical_id: `${canonical(event)}:${commandHash.slice(0, 20)}`,
-        display_name: `${event} \xB7 ${basename3(String(entry.command).split(/\s+/)[0] || "hook")}`,
+        display_name: `${event} \xB7 ${basename4(String(entry.command).split(/\s+/)[0] || "hook")}`,
         enabled: entry.enabled !== false,
         config_scope: "user",
-        package_name: basename3(String(entry.command).split(/\s+/)[0] || "") || void 0,
+        package_name: basename4(String(entry.command).split(/\s+/)[0] || "") || void 0,
         config_hash: commandHash,
         metadata: { managed, events: [event] }
       });
@@ -19018,7 +19851,7 @@ function parseFrontmatter(content) {
   return { name: value("name"), version: value("version") };
 }
 function skillArtifacts(harness, root) {
-  if (!existsSync42(root)) return [];
+  if (!existsSync43(root)) return [];
   const manifests = [];
   const visit = (dir) => {
     let entries;
@@ -19029,7 +19862,7 @@ function skillArtifacts(harness, root) {
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink?.()) continue;
-      const path = join42(dir, entry.name);
+      const path = join43(dir, entry.name);
       if (entry.isFile() && entry.name === "SKILL.md") manifests.push(path);
       else if (entry.isDirectory()) visit(path);
     }
@@ -19039,7 +19872,7 @@ function skillArtifacts(harness, root) {
     const content = readText(path);
     const frontmatter = parseFrontmatter(content);
     const rel = relative(root, path).replaceAll("\\", "/");
-    const name = frontmatter.name || basename3(join42(path, "..")) || "skill";
+    const name = frontmatter.name || basename4(join43(path, "..")) || "skill";
     return {
       harness,
       type: "skill",
@@ -19054,7 +19887,7 @@ function skillArtifacts(harness, root) {
   });
 }
 function cursorExtensionArtifacts(root) {
-  if (!existsSync42(root)) return [];
+  if (!existsSync43(root)) return [];
   let dirs = [];
   try {
     dirs = readdirSync11(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink());
@@ -19063,7 +19896,7 @@ function cursorExtensionArtifacts(root) {
   }
   const artifacts = [];
   for (const dir of dirs) {
-    const pkg = readJson(join42(root, dir.name, "package.json"));
+    const pkg = readJson(join43(root, dir.name, "package.json"));
     if (!pkg) continue;
     const publisher = typeof pkg.publisher === "string" ? pkg.publisher : void 0;
     const name = typeof pkg.name === "string" ? pkg.name : dir.name;
@@ -19083,20 +19916,20 @@ function cursorExtensionArtifacts(root) {
   return artifacts;
 }
 function deploymentMode2(home) {
-  const raw = readText(join42(home, ".synkro", "config.env"));
+  const raw = readText(join43(home, ".synkro", "config.env"));
   const value = (key) => raw.match(new RegExp(`^${key}=['"]?([^'"\\n]*)`, "m"))?.[1]?.toLowerCase();
   if (value("SYNKRO_GRADING_MODE") === "byok") return "byok";
   if (value("SYNKRO_STORAGE_MODE") === "cloud") return "cloud";
   return "local";
 }
 function telemetryHealth(home) {
-  const meta = readJson(join42(home, ".synkro", "telemetry-meta.json"));
+  const meta = readJson(join43(home, ".synkro", "telemetry-meta.json"));
   const health = {};
   if (meta?.last_flush_ok_at && Number.isFinite(Date.parse(meta.last_flush_ok_at))) health.telemetry_last_flush_at = meta.last_flush_ok_at;
   if (meta?.last_flush_error) health.telemetry_last_error = "flush_failed";
-  const queue = join42(home, ".synkro", "telemetry-pending.jsonl");
+  const queue = join43(home, ".synkro", "telemetry-pending.jsonl");
   try {
-    const size = statSync5(queue).size;
+    const size = statSync6(queue).size;
     health.telemetry_backlog = size <= 5 * 1024 * 1024 ? readFileSync39(queue, "utf8").split("\n").filter(Boolean).length : Math.ceil(size / 1024);
   } catch {
   }
@@ -19138,7 +19971,7 @@ function harnessSnapshot(agent) {
   }
   const config = readJson(agent.settingsPath);
   const coverage = inspectCodexHooks(agent.settingsPath);
-  const toml = readText(join42(agent.configDir, "config.toml"));
+  const toml = readText(join43(agent.configDir, "config.toml"));
   const permission = toml.match(/^\s*approval_policy\s*=\s*["']([^"']+)/m)?.[1];
   return {
     row: {
@@ -19155,11 +19988,11 @@ function harnessSnapshot(agent) {
   };
 }
 function collectOperationalInventory(options = {}) {
-  const home = options.homeDir ?? homedir44();
+  const home = options.homeDir ?? homedir45();
   const detected = options.detectedAgents ?? detectAgents();
   const identity = getOperationalInstallationIdentity(options.identityPath);
   const targetPlatform = options.platformName ?? platform6();
-  const codexHome = options.homeDir ? join42(home, ".codex") : process.env.CODEX_HOME || join42(home, ".codex");
+  const codexHome = options.homeDir ? join43(home, ".codex") : process.env.CODEX_HOME || join43(home, ".codex");
   const harnesses = [];
   const artifacts = [];
   for (const agent of detected) {
@@ -19167,7 +20000,7 @@ function collectOperationalInventory(options = {}) {
     harnesses.push(row2);
     artifacts.push(...hookArtifacts(row2.harness, config));
   }
-  const claudeJson = readJson(join42(home, ".claude.json"));
+  const claudeJson = readJson(join43(home, ".claude.json"));
   artifacts.push(...mcpArtifactsFromJson("claude_code", claudeJson));
   if (claudeJson?.projects && typeof claudeJson.projects === "object") {
     for (const [projectPath, project] of Object.entries(claudeJson.projects)) {
@@ -19175,8 +20008,8 @@ function collectOperationalInventory(options = {}) {
       artifacts.push(...mcpArtifactsFromJson("claude_code", project, `local:${sha256(projectPath).slice(0, 16)}`));
     }
   }
-  artifacts.push(...mcpArtifactsFromJson("cursor", readJson(join42(home, ".cursor", "mcp.json"))));
-  artifacts.push(...codexMcpArtifacts(readText(join42(codexHome, "config.toml"))));
+  artifacts.push(...mcpArtifactsFromJson("cursor", readJson(join43(home, ".cursor", "mcp.json"))));
+  artifacts.push(...codexMcpArtifacts(readText(join43(codexHome, "config.toml"))));
   const projectRoots = discoveredProjectRoots(
     claudeJson,
     options.currentDirectory ?? process.cwd(),
@@ -19187,11 +20020,11 @@ function collectOperationalInventory(options = {}) {
     const scopeHash = sha256(projectRoot).slice(0, 16);
     artifacts.push(...mcpArtifactsFromJson(
       "claude_code",
-      readJson(join42(projectRoot, ".mcp.json")),
+      readJson(join43(projectRoot, ".mcp.json")),
       `project:${scopeHash}`
     ));
-    const cursorProjectConfig = join42(projectRoot, ".cursor", "mcp.json");
-    if (resolve5(cursorProjectConfig) !== resolve5(join42(home, ".cursor", "mcp.json"))) {
+    const cursorProjectConfig = join43(projectRoot, ".cursor", "mcp.json");
+    if (resolve6(cursorProjectConfig) !== resolve6(join43(home, ".cursor", "mcp.json"))) {
       artifacts.push(...mcpArtifactsFromJson(
         "cursor",
         readJson(cursorProjectConfig),
@@ -19202,7 +20035,7 @@ function collectOperationalInventory(options = {}) {
   for (const managedPath of claudeManagedMcpConfigCandidates(targetPlatform)) {
     artifacts.push(...mcpArtifactsFromJson("claude_code", readJson(managedPath), "managed"));
   }
-  const desktopConfigPath = claudeDesktopConfigCandidates(home, targetPlatform).find((path) => existsSync42(path));
+  const desktopConfigPath = claudeDesktopConfigCandidates(home, targetPlatform).find((path) => existsSync43(path));
   if (desktopConfigPath) {
     const desktopConfig = readJson(desktopConfigPath);
     harnesses.push({
@@ -19213,7 +20046,7 @@ function collectOperationalInventory(options = {}) {
     });
     artifacts.push(...mcpArtifactsFromJson("claude_desktop", desktopConfig));
   }
-  const claudeSettings = readJson(join42(home, ".claude", "settings.json"));
+  const claudeSettings = readJson(join43(home, ".claude", "settings.json"));
   if (claudeSettings?.enabledPlugins && typeof claudeSettings.enabledPlugins === "object") {
     for (const [name, enabled] of Object.entries(claudeSettings.enabledPlugins)) {
       artifacts.push({
@@ -19227,10 +20060,10 @@ function collectOperationalInventory(options = {}) {
       });
     }
   }
-  artifacts.push(...skillArtifacts("claude_code", join42(home, ".claude", "skills")));
-  artifacts.push(...skillArtifacts("cursor", join42(home, ".cursor", "skills")));
-  artifacts.push(...skillArtifacts("codex", join42(codexHome, "skills")));
-  artifacts.push(...cursorExtensionArtifacts(join42(home, ".cursor", "extensions")));
+  artifacts.push(...skillArtifacts("claude_code", join43(home, ".claude", "skills")));
+  artifacts.push(...skillArtifacts("cursor", join43(home, ".cursor", "skills")));
+  artifacts.push(...skillArtifacts("codex", join43(codexHome, "skills")));
+  artifacts.push(...cursorExtensionArtifacts(join43(home, ".cursor", "extensions")));
   const uniqueArtifacts = /* @__PURE__ */ new Map();
   for (const artifact of artifacts) {
     const key = `${artifact.harness || "global"}:${artifact.type}:${artifact.canonical_id}`;
@@ -19283,18 +20116,18 @@ __export(sync_exports2, {
   syncOperationalInventoryDetached: () => syncOperationalInventoryDetached
 });
 import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
-import { spawn as spawn10 } from "child_process";
+import { spawn as spawn11 } from "child_process";
 import {
-  existsSync as existsSync43,
+  existsSync as existsSync44,
   mkdirSync as mkdirSync25,
   readFileSync as readFileSync40,
   renameSync as renameSync10,
-  writeFileSync as writeFileSync30
+  writeFileSync as writeFileSync31
 } from "fs";
-import { homedir as homedir45 } from "os";
-import { dirname as dirname13, join as join43 } from "path";
+import { homedir as homedir46 } from "os";
+import { dirname as dirname14, join as join44 } from "path";
 function syncStatePath() {
-  return process.env.SYNKRO_INVENTORY_SYNC_STATE_PATH || join43(homedir45(), ".synkro", "inventory-sync.json");
+  return process.env.SYNKRO_INVENTORY_SYNC_STATE_PATH || join44(homedir46(), ".synkro", "inventory-sync.json");
 }
 function readState(path = syncStatePath()) {
   try {
@@ -19306,9 +20139,9 @@ function readState(path = syncStatePath()) {
 }
 function writeState(state, path = syncStatePath()) {
   try {
-    mkdirSync25(dirname13(path), { recursive: true, mode: 448 });
+    mkdirSync25(dirname14(path), { recursive: true, mode: 448 });
     const temp = `${path}.${process.pid}.tmp`;
-    writeFileSync30(temp, JSON.stringify(state, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+    writeFileSync31(temp, JSON.stringify(state, null, 2) + "\n", { encoding: "utf8", mode: 384 });
     renameSync10(temp, path);
   } catch {
   }
@@ -19321,7 +20154,7 @@ function shouldSyncInventory(state, now = Date.now(), target) {
   return !Number.isFinite(lastAttempt) || lastAttempt <= 0 || now - lastAttempt >= FAILURE_RETRY_MS;
 }
 function readConfig() {
-  const path = join43(homedir45(), ".synkro", "config.env");
+  const path = join44(homedir46(), ".synkro", "config.env");
   const out = {};
   try {
     for (const rawLine of readFileSync40(path, "utf8").split("\n")) {
@@ -19363,7 +20196,7 @@ function resolveInventoryGateway(raw) {
 }
 async function loadToken() {
   try {
-    const durable = readFileSync40(join43(homedir45(), ".synkro", ".mcp-jwt"), "utf8").trim();
+    const durable = readFileSync40(join44(homedir46(), ".synkro", ".mcp-jwt"), "utf8").trim();
     if (durable) return durable;
   } catch {
   }
@@ -19481,8 +20314,8 @@ function syncOperationalInventoryDetached() {
   writeState({ ...state, last_attempt_at: (/* @__PURE__ */ new Date()).toISOString(), last_target: target }, path);
   try {
     const script = process.argv[1];
-    if (!script || !existsSync43(script)) return;
-    const child = spawn10(process.execPath, [script, "inventory-sync", "--detached"], {
+    if (!script || !existsSync44(script)) return;
+    const child = spawn11(process.execPath, [script, "inventory-sync", "--detached"], {
       detached: true,
       stdio: "ignore",
       env: { ...process.env, SYNKRO_INVENTORY_DETACHED: "1" }
@@ -19505,14 +20338,14 @@ var init_sync2 = __esm({
 });
 
 // cli/bootstrap.js
-import { readFileSync as readFileSync41, existsSync as existsSync44 } from "fs";
-import { resolve as resolve6 } from "path";
+import { readFileSync as readFileSync41, existsSync as existsSync45 } from "fs";
+import { resolve as resolve7 } from "path";
 process.title = "synkro";
 var envCandidates = [
-  resolve6(process.env.HOME ?? "", ".synkro", "config.env")
+  resolve7(process.env.HOME ?? "", ".synkro", "config.env")
 ];
 for (const envPath of envCandidates) {
-  if (!existsSync44(envPath)) continue;
+  if (!existsSync45(envPath)) continue;
   const envContent = readFileSync41(envPath, "utf-8");
   for (const line of envContent.split("\n")) {
     const trimmed = line.trim();
@@ -19530,7 +20363,7 @@ var subArgs = args.slice(1);
 var isDetachedChild = process.env.SYNKRO_TELEMETRY_DETACHED === "1";
 var FLUSH_SKIP = /* @__PURE__ */ new Set(["grade", "inventory-sync", "version", "--version", "-v", "help", "--help", "-h", ""]);
 function printVersion() {
-  console.log("1.10.6");
+  console.log("1.10.8");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents