@synkro-sh/cli 1.10.4 → 1.10.6

package/dist/bootstrap.js

@@ -147,7 +147,7 @@ function getIdentity() {
   if (cached2) return cached2;
   let cliVersion2 = "0.0.0";
   try {
-    cliVersion2 = "1.10.4";
+    cliVersion2 = "1.10.6";
   } catch {
   }
   const creds = loadCredentialsIdentity();
@@ -3255,10 +3255,15 @@ function pruneToolCallMarks(now: number): void {
 
 // The user's answer to "move into the task worktree, or stay here?". Written by the
 // "synkro workspace stay" command (the CLI owns ~/.synkro, so nothing hand-writes it)
-// and read here. Keyed by task alone: the decision resets when the active task
-// changes, which is the scope the workspace gate is asking about.
+// and read here. The filename includes a one-way session key so consent in one
+// Claude/Codex chat can never silently authorize another chat working the task.
 const WORKSPACE_CHOICE_DIR = join(HOME, '.synkro', 'workspace-choice');
 
+function taskWorkspaceChoicePath(taskId: string, sessionId: string): string {
+  const sessionKey = createHash('sha256').update(String(sessionId || '')).digest('hex').slice(0, 16);
+  return join(WORKSPACE_CHOICE_DIR, taskId + '.' + sessionKey + '.stay');
+}
+
 // The user answers the workspace question in plain language on their next
 // prompt. Writing the marker is exactly what the CLI's "workspace stay"
 // command does — but the consent matcher only accepts one literal spelling,
@@ -3279,14 +3284,23 @@ function isWorkspaceStayIntent(prompt: string): boolean {
   ].some((pattern) => pattern.test(normalized));
 }
 
-function taskWorkspaceStayRecorded(taskId: string): boolean {
-  if (!/^task_[a-z0-9]{8}$/i.test(String(taskId || ''))) return false;
-  try { return existsSync(join(WORKSPACE_CHOICE_DIR, taskId + '.stay')); } catch { return false; }
+function taskWorkspaceStayRecorded(taskId: string, sessionId: string): boolean {
+  if (!/^task_[a-z0-9]{8}$/i.test(String(taskId || '')) || !sessionId) return false;
+  try { return existsSync(taskWorkspaceChoicePath(taskId, sessionId)); } catch { return false; }
 }
 
-// Our own context string, so the shape is stable: '... task=<id> ...'.
-function taskIdFromScmContext(context: string): string {
-  const marker = ' task=';
+function recordTaskWorkspaceStay(taskId: string, sessionId: string): boolean {
+  if (!/^task_[a-z0-9]{8}$/i.test(String(taskId || '')) || !sessionId) return false;
+  try {
+    mkdirSync(WORKSPACE_CHOICE_DIR, { recursive: true });
+    writeFileSync(taskWorkspaceChoicePath(taskId, sessionId), new Date().toISOString() + '\n', { mode: 0o600 });
+    return true;
+  } catch { return false; }
+}
+
+// Our own context string, so the shape is stable: '... task=<id> branch=<name> ...'.
+function fieldFromScmContext(context: string, field: string): string {
+  const marker = ' ' + field + '=';
   const at = String(context || '').indexOf(marker);
   if (at === -1) return '';
   const rest = context.slice(at + marker.length);
@@ -3294,14 +3308,73 @@ function taskIdFromScmContext(context: string): string {
   return (end === -1 ? rest : rest.slice(0, end)).trim();
 }
 
+function taskIdFromScmContext(context: string): string {
+  return fieldFromScmContext(context, 'task');
+}
+
+// An exact-command allowance must not be defeated by the output plumbing agents
+// reflexively append ('2>&1 | tail -2') — requiring the bare spelling made the
+// gate's own escape hatch block itself (observed live). Only harmless trailing
+// redirection plus a single display filter pass; anything that could chain a
+// second command (&&, ;, extra pipes, substitution) still rejects.
+function isBareCommandWithPlumbing(command: string, head: string): boolean {
+  if (!command.startsWith(head)) return false;
+  const rest = command.slice(head.length);
+  return /^(?:\s+2>&1)?(?:\s*\|\s*(?:tail|head|cat)(?:\s+[-\w.+]+)*)?\s*$/.test(rest);
+}
+
+function bashCommandOf(payload: any): string {
+  if (String(payload?.tool_name || '') !== 'Bash') return '';
+  const input = payload?.tool_input && typeof payload.tool_input === 'object' ? payload.tool_input : {};
+  return String(input.command || input.cmd || '').trim();
+}
+
 // Consent must never deadlock behind the block it resolves: the command that records
 // the answer is allowed through for the task currently being asked about, and nothing
 // else is.
-function isWorkspaceConsentCommand(payload: any, taskId: string): boolean {
-  if (!taskId || String(payload?.tool_name || '') !== 'Bash') return false;
+function workspaceReadOnlyShellSegment(segment: string): boolean {
+  const value = String(segment || '').trim();
+  if (!value || /[;&><$]/.test(value) || value.includes(String.fromCharCode(96))) return false;
+  const tokens = value.split(/\s+/);
+  const verb = String(tokens[0] || '').toLowerCase();
+  const writeOptions = new Set(['-i', '--in-place', '-o', '--output', '--output-document']);
+  if (tokens.some((token) => writeOptions.has(token) || token.startsWith('--output='))) return false;
+  const reads = new Set(['cat', 'head', 'tail', 'grep', 'egrep', 'fgrep', 'rg', 'ag', 'find', 'fd', 'ls', 'wc', 'cmp', 'diff', 'file', 'stat', 'pwd', 'sort', 'uniq', 'cut', 'tr', 'jq', 'yq']);
+  if (reads.has(verb)) {
+    if ((verb === 'find' || verb === 'fd') && tokens.some((token) => new Set(['-exec', '-execdir', '-ok', '-okdir', '-delete', '-fprint', '-fprint0', '-fls', '--exec', '--exec-batch']).has(token))) return false;
+    return true;
+  }
+  if (verb !== 'git') return false;
+  return new Set(['log', 'show', 'diff', 'blame', 'status', 'rev-parse', 'ls-files', 'ls-tree', 'cat-file', 'shortlog', 'describe']).has(String(tokens[1] || '').toLowerCase());
+}
+
+function isWorkspaceReadOnlyDiagnostic(payload: any): boolean {
+  const toolName = String(payload?.tool_name || '');
+  if (/^(?:Read|ReadFile|read_file|Grep|grep_search|codebase_search|file_search|Glob|list_dir)$/i.test(toolName)) return true;
+  if (!/^(?:Bash|Shell|terminal|run_terminal_cmd|execute_command)$/i.test(toolName)) return false;
   const input = payload?.tool_input && typeof payload.tool_input === 'object' ? payload.tool_input : {};
   const command = String(input.command || input.cmd || '').trim();
-  return command === 'synkro workspace stay ' + taskId;
+  if (!command || /\|\||(^|[^&])&([^&]|$)|;/.test(command)) return false;
+  return command.split('|').every(workspaceReadOnlyShellSegment);
+}
+
+function isWorkspaceConsentCommand(payload: any, taskId: string): boolean {
+  if (!taskId) return false;
+  const command = bashCommandOf(payload);
+  return Boolean(command) && isBareCommandWithPlumbing(command, 'synkro workspace stay ' + taskId);
+}
+
+// A session that is already inside the task worktree but on the wrong branch needs
+// exactly one repair: checking out the canonical branch. The gate demands that
+// branch, so blocking the checkout that reaches it would deadlock (observed live
+// after an agent created a side branch in the task worktree). Elsewhere the command
+// is harmless: git itself refuses to check out a branch held by another worktree.
+function isWorkspaceRepairCommand(payload: any, branchName: string): boolean {
+  if (!branchName) return false;
+  const command = bashCommandOf(payload);
+  if (!command) return false;
+  return isBareCommandWithPlumbing(command, 'git checkout ' + branchName)
+    || isBareCommandWithPlumbing(command, 'git switch ' + branchName);
 }
 
 function firstHookForToolCall(sessionId: string, payload: any): boolean {
@@ -3666,7 +3739,7 @@ function shellTaskWorkspaceArg(value: string): string {
   return "'" + value.replace(/'/g, "'\"'\"'") + "'";
 }
 
-function taskScmWorkspaceInstruction(harness: string, sessionId: string, workspace: any): string {
+function taskScmWorkspaceInstruction(harness: string, sessionId: string, workspace: any, root = ''): string {
   const context = taskScmWorkspaceContext(workspace, harness);
   const worktreePath = String(workspace?.worktreePath || '');
   const branchName = String(workspace?.branchName || '');
@@ -3676,6 +3749,15 @@ function taskScmWorkspaceInstruction(harness: string, sessionId: string, workspa
     + 'the task worktree and canonical branch.';
   if (harness === 'cc') {
     if (!worktreePath) return context + '\nTask worktree creation failed closed; retry workspace preparation.';
+    // Already inside the task worktree, just not on its branch: the move/stay
+    // question was answered the moment the session got here, and re-asking it
+    // offers two exits that both fail. Name the one command that repairs it —
+    // the gate lets exactly that command through.
+    if (root && samePath(root, worktreePath)) {
+      return context + '\nThis session is already in the task worktree but not on its canonical branch. '
+        + 'Run "git checkout ' + branchName + '" to continue; that command is allowed through this gate, '
+        + 'and substantive tools stay blocked until the branch matches.';
+    }
     // Ask, do not command. The user may legitimately want to keep working where they
     // are, and Synkro should not move them without their say-so.
     return context + '\nAsk the user whether to move this task into its isolated worktree '
@@ -3691,14 +3773,18 @@ function taskScmWorkspaceInstruction(harness: string, sessionId: string, workspa
       + '. Confirm the resumed workspace is on branch ' + JSON.stringify(branchName) + '. ' + requirement;
   }
   if (!worktreePath) {
-    return context + '\n[synkro:workspace-handoff] Invoke Codex\'s native task/worktree Handoff now for this exact task. '
-      + 'Check out branch ' + JSON.stringify(branchName) + ' in a new worktree and continue this same chat there. '
-      + 'Do not switch the shared Local checkout or ask the user to switch branches. '
-      + 'Synkro keeps substantive tools blocked until this exact session reports the new worktree path and canonical branch.';
+    return context + '\nAsk the user whether to move this task into a generated isolated Codex worktree on branch '
+      + JSON.stringify(branchName) + ', or keep working in the current workspace. Do not decide for them. '
+      + 'To move: use Codex\'s Environment control or native Handoff for this task; never hand off a different task as a workaround. '
+      + 'To stay: run "synkro workspace stay ' + String(workspace?.taskId || '') + '". '
+      + 'Never switch the shared Local checkout.';
   }
-  return context + '\n[synkro:workspace-handoff] Invoke Codex\'s native task/worktree Handoff now for this exact task, '
-    + 'using the existing worktree ' + JSON.stringify(worktreePath) + ' on branch ' + JSON.stringify(branchName) + '. '
-    + 'The Codex Environment panel must show that worktree and branch before retrying the blocked action. ' + requirement;
+  return context + '\nAsk the user whether to move this task to its prepared worktree '
+    + JSON.stringify(worktreePath) + ' on branch ' + JSON.stringify(branchName)
+    + ', or keep working in the current isolated Codex worktree. Do not decide for them. '
+    + 'To move: use Codex\'s Environment control or native Handoff for this task; never hand off a different task as a workaround. '
+    + 'To stay: run "synkro workspace stay ' + String(workspace?.taskId || '') + '". '
+    + 'Never switch the shared Local checkout.';
 }
 
 // CC validates hookSpecificOutput.hookEventName against the event that actually fired.
@@ -3780,7 +3866,7 @@ async function reconcileTaskScm(
         : result?.workspace;
       return {
         reason: result?.waiting
-          ? (taskScmWorkspaceInstruction(harness, sessionId, workspace)
+          ? (taskScmWorkspaceInstruction(harness, sessionId, workspace, root)
             || String(result.reason || 'task source-control preparation is pending'))
           : '',
         context: taskScmWorkspaceContext(workspace, harness),
@@ -4479,19 +4565,21 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
     // prompt records the same durable marker the CLI command writes. Reconcile
     // just told us WHICH task is being asked, so no extra state is needed and
     // ordinary prompts outside a pending ask are never scanned.
-    if (surface === 'prompt-submit' && scm.reason && scmTaskId && !taskWorkspaceStayRecorded(scmTaskId)) {
+    if (surface === 'prompt-submit' && scm.reason && scmTaskId && !taskWorkspaceStayRecorded(scmTaskId, sessionId)) {
       const promptText = String(payload.prompt || payload.user_message || '');
       if (isWorkspaceStayIntent(promptText)) {
-        try {
-          mkdirSync(WORKSPACE_CHOICE_DIR, { recursive: true });
-          writeFileSync(join(WORKSPACE_CHOICE_DIR, scmTaskId + '.stay'), new Date().toISOString() + '\n');
-        } catch { /* fail-open: the CLI command and the exact-string path remain */ }
+        recordTaskWorkspaceStay(scmTaskId, sessionId);
       }
     }
-    // The user was asked and chose to keep working here, or is answering right now.
+    const workspaceConsentCommand = Boolean(scmTaskId) && isWorkspaceConsentCommand(payload, scmTaskId);
+    if (workspaceConsentCommand) recordTaskWorkspaceStay(scmTaskId, sessionId);
+    // The user was asked and chose to keep working here, is answering right now,
+    // or the tool call is the one git command that repairs the workspace itself.
     const workspaceConsentSettled = Boolean(scmTaskId)
-      && (taskWorkspaceStayRecorded(scmTaskId) || isWorkspaceConsentCommand(payload, scmTaskId));
-    if (scm.reason && substantiveTool && !workspaceConsentSettled) {
+      && (taskWorkspaceStayRecorded(scmTaskId, sessionId)
+        || workspaceConsentCommand
+        || isWorkspaceRepairCommand(payload, fieldFromScmContext(scm.context, 'branch')));
+    if (scm.reason && substantiveTool && !workspaceConsentSettled && !isWorkspaceReadOnlyDiagnostic(payload)) {
       out(taskScmBlockResponse(harness, scm.reason, firstHookForToolCall(sessionId, payload)));
       return;
     }
@@ -4680,7 +4768,7 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
     let scmContext = scm.context && surface === 'prompt-submit' && firstHookForToolCall(sessionId, payload) ? scm.context : '';
     // Say plainly that work is continuing outside the task worktree by the user's choice,
     // so the state is never mistaken for a binding that silently failed.
-    if (scmContext && scmTaskId && taskWorkspaceStayRecorded(scmTaskId)) {
+    if (scmContext && scmTaskId && taskWorkspaceStayRecorded(scmTaskId, sessionId)) {
       scmContext += ' workspace=staying-here-by-user-choice';
     }
     const responseText = withActualHookEvent(withTaskScmContext(contractResponseText, harness, scmContext), payload);
@@ -5023,6 +5111,7 @@ if (process.env.SYNKRO_HOOK_FORMAT === 'codex' && hookEventName === 'PermissionR
 // cli/auth/stub.ts
 var stub_exports = {};
 __export(stub_exports, {
+  accessTokenExpired: () => accessTokenExpired,
   authedFetch: () => authedFetch,
   authenticate: () => authenticate,
   clearCredentials: () => clearCredentials,
@@ -5280,19 +5369,23 @@ function getAccessToken() {
   const creds = loadCredentials();
   return creds?.access_token || null;
 }
-function isTokenExpired() {
-  const creds = loadCredentials();
-  if (!creds) return true;
+function accessTokenExpired(accessToken, now = Date.now()) {
   try {
-    const decoded = jwt.decode(creds.access_token);
+    const decoded = jwt.decode(accessToken);
     if (!decoded?.exp) return true;
     const expiresAt = decoded.exp * 1e3;
-    const buffer = 5 * 60 * 1e3;
-    return Date.now() > expiresAt - buffer;
+    const lifetimeMs = decoded.iat ? (decoded.exp - decoded.iat) * 1e3 : 0;
+    const buffer = lifetimeMs > 0 ? Math.min(MAX_EXPIRY_BUFFER_MS, Math.floor(lifetimeMs / 5)) : MAX_EXPIRY_BUFFER_MS;
+    return now > expiresAt - buffer;
   } catch {
     return true;
   }
 }
+function isTokenExpired() {
+  const creds = loadCredentials();
+  if (!creds?.access_token) return true;
+  return accessTokenExpired(creds.access_token);
+}
 async function refreshToken() {
   const creds = loadCredentials();
   if (!creds?.refresh_token) return false;
@@ -5360,7 +5453,7 @@ async function getSecrets(userId, integrationId) {
     LANGSMITH_API_KEY: process.env.USER_LANGSMITH_KEY || ""
   };
 }
-var PORT, RAW_WEB_AUTH_URL, SYNKRO_WEB_AUTH_URL, AUTH_FILE, RAW_API_URL, SYNKRO_API_URL, ERROR_HTML, refreshPromise;
+var PORT, RAW_WEB_AUTH_URL, SYNKRO_WEB_AUTH_URL, AUTH_FILE, RAW_API_URL, SYNKRO_API_URL, ERROR_HTML, MAX_EXPIRY_BUFFER_MS, refreshPromise;
 var init_stub = __esm({
   "cli/auth/stub.ts"() {
     "use strict";
@@ -5410,6 +5503,7 @@ var init_stub = __esm({
 </body>
 </html>
 `;
+    MAX_EXPIRY_BUFFER_MS = 60 * 1e3;
     refreshPromise = null;
   }
 });
@@ -7840,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.4";
+      if (true) return "1.10.6";
       try {
         const pkg = JSON.parse(readFileSync17(new URL("../../package.json", import.meta.url), "utf8"));
         if (pkg.version) return pkg.version;
@@ -8900,7 +8994,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle2(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle2(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle2(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle2("1.10.4")}`
+    `SYNKRO_VERSION=${shellQuoteSingle2("1.10.6")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle2(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle2(safeUserId)}`);
@@ -9647,7 +9741,7 @@ async function installCommand(opts = {}) {
   await setTelemetryState({ enabled: true, remoteFlushEnabled: telemetryConsent });
   emit("install", {
     phase: "started",
-    cli_version_to: "1.10.4",
+    cli_version_to: "1.10.6",
     agents_detected: agents.map((a) => a.kind),
     with_github: false,
     with_local_cc: false,
@@ -14429,6 +14523,16 @@ import { homedir as homedir31 } from "os";
 function markerPath(taskId) {
   return join31(WORKSPACE_CHOICE_DIR, `${taskId}.stay`);
 }
+function markerNamesForTask(taskId) {
+  try {
+    return existsSync33(WORKSPACE_CHOICE_DIR) ? readdirSync8(WORKSPACE_CHOICE_DIR).filter((name) => name === `${taskId}.stay` || name.startsWith(`${taskId}.`) && name.endsWith(".stay")) : [];
+  } catch {
+    return [];
+  }
+}
+function taskIdFromMarker(name) {
+  return (name.match(/^(task_[a-z0-9]{8})(?:\.[a-f0-9]{16})?\.stay$/i) || [])[1] || "";
+}
 function usage() {
   console.log(`synkro workspace \u2014 record where a task's work happens
 
@@ -14437,8 +14541,8 @@ Usage:
   synkro workspace clear <taskId>    forget the choice (the gate asks again)
   synkro workspace status [taskId]   show recorded choices
 
-The gate asks once per task. "stay" is remembered until the choice is cleared or
-the active task changes.`);
+The gate asks once per task session. "stay" is remembered in that chat until the
+choice is cleared or the active task changes.`);
 }
 async function workspaceCommand(args2) {
   const sub = String(args2[0] || "").trim();
@@ -14455,7 +14559,7 @@ async function workspaceCommand(args2) {
       recorded = [];
     }
     if (taskId) {
-      const on = recorded.includes(`${taskId}.stay`);
+      const on = markerNamesForTask(taskId).length > 0;
       console.log(`${taskId}: ${on ? "stay recorded" : "no choice recorded"}`);
       return;
     }
@@ -14464,7 +14568,7 @@ async function workspaceCommand(args2) {
       return;
     }
     console.log("Staying in the current checkout for:");
-    for (const name of recorded.sort()) console.log(`  ${name.replace(/\.stay$/, "")}`);
+    for (const id of [...new Set(recorded.map(taskIdFromMarker).filter(Boolean))].sort()) console.log(`  ${id}`);
     return;
   }
   if (sub !== "stay" && sub !== "clear") {
@@ -14479,9 +14583,11 @@ async function workspaceCommand(args2) {
     return;
   }
   if (sub === "clear") {
-    try {
-      rmSync5(markerPath(taskId), { force: true });
-    } catch {
+    for (const name of markerNamesForTask(taskId)) {
+      try {
+        rmSync5(join31(WORKSPACE_CHOICE_DIR, name), { force: true });
+      } catch {
+      }
     }
     console.log(`Cleared the workspace choice for ${taskId}.`);
     return;
@@ -15039,6 +15145,10 @@ async function styleOuterSession(bootPath, repoCwd, sidebarWidth) {
     // focus it, click rows/chips. Without this the fixed split reads as
     // "blocked in".
     ["set-option", "-t", UI_SESSION, "mouse", "on"],
+    // Scrollback deep enough to hold a real working session. tmux defaults to
+    // 2000 lines, which a long harness session blows through — the start of the
+    // conversation would silently fall off the top with no way back to it.
+    ["set-option", "-t", UI_SESSION, "history-limit", "50000"],
     ["set-option", "-t", UI_SESSION, "status-position", "top"],
     ["set-option", "-t", UI_SESSION, "status-style", "bg=colour233,fg=colour245"],
     ["set-option", "-t", UI_SESSION, "status-format[0]", chipStrip(sidebarWidth)],
@@ -15064,6 +15174,7 @@ async function styleOuterSession(bootPath, repoCwd, sidebarWidth) {
   for (const argv of style) await run(HOST, ["tmux", ...argv]);
 }
 async function buildTab(bootPath, repoCwd, spec) {
+  await run(HOST, ["tmux", "set-option", "-g", "history-limit", "50000"]);
   let windowTarget;
   if (!await uiSessionExists()) {
     const cols = String(Number(process.stdout.columns || 0) || 220);
@@ -15132,11 +15243,29 @@ async function uiSessionExists() {
   const result = await run(HOST, ["tmux", "has-session", "-t", UI_SESSION]);
   return result.ok;
 }
+function parseCollapsedClients(listOutput) {
+  return String(listOutput || "").split("\n").map((line) => line.trim().split("|")).filter(([name, width, height]) => Boolean(name) && Number.isFinite(Number(width)) && Number.isFinite(Number(height)) && (Number(width) < 20 || Number(height) < 5)).map(([name]) => name);
+}
+async function pruneCollapsedClients() {
+  const listed = await run(HOST, [
+    "tmux",
+    "list-clients",
+    "-t",
+    UI_SESSION,
+    "-F",
+    "#{client_name}|#{client_width}|#{client_height}"
+  ]);
+  if (!listed.ok) return 0;
+  const collapsed = parseCollapsedClients(listed.stdout);
+  for (const name of collapsed) await run(HOST, ["tmux", "detach-client", "-t", name]);
+  return collapsed.length;
+}
 async function launchUi(bootPath, repoCwd) {
   rememberSpace(repoCwd);
   if (!await uiSessionExists()) {
     await buildTab(bootPath, repoCwd, { cwd: repoCwd, center: makeTerminalCommand(bootPath), focus: "sidebar" });
   }
+  await pruneCollapsedClients();
   return runInherit(process.env.TMUX ? ["tmux", "switch-client", "-t", UI_SESSION] : ["tmux", "attach-session", "-t", UI_SESSION]);
 }
 var HOST, TAB_GLYPHS;
@@ -16705,11 +16834,14 @@ var init_events = __esm({
 });
 
 // cli/harness/cursor.ts
+function unwrapReplay(text) {
+  return text.replace(/<\/?user_query>/gi, "").trim();
+}
 function textOf(message) {
   const content = message?.content;
-  if (typeof content === "string") return content.trim();
+  if (typeof content === "string") return unwrapReplay(content);
   if (!Array.isArray(content)) return "";
-  return content.filter((part) => part && (part.type === "text" || typeof part.text === "string")).map((part) => String(part.text || "")).join("").trim();
+  return unwrapReplay(content.filter((part) => part && (part.type === "text" || typeof part.text === "string")).map((part) => String(part.text || "")).join(""));
 }
 function toolPayload(toolCall) {
   if (!toolCall) return { kind: "other", body: {} };
@@ -16784,6 +16916,15 @@ function parseCursorLine(line) {
     }
     return [];
   }
+  if (type === "retry") {
+    if (subtype !== "starting") return [];
+    const attempt = Number(frame.attempt || 0);
+    return [{
+      type: "notice",
+      kind: "retry",
+      text: "connection dropped, resuming" + (attempt ? " (attempt " + attempt + ")" : "") + "\u2026"
+    }];
+  }
   if (type === "result") {
     return [{
       type: "turn-end",
@@ -16793,6 +16934,15 @@ function parseCursorLine(line) {
   }
   return [];
 }
+function stderrNotice(raw) {
+  const text = String(raw || "").trim();
+  if (!text) return "";
+  if (/ActionRequiredError/i.test(text) && /usage limit/i.test(text)) {
+    return "Cursor usage limit reached \u2014 replies still land, but turns will keep stalling until the plan resets or is topped up";
+  }
+  if (/RetriableError/i.test(text)) return "";
+  return /error|fatal/i.test(text) ? text : "";
+}
 function feed(buffer, chunk) {
   const combined = buffer + chunk;
   const parts = combined.split("\n");
@@ -16832,43 +16982,70 @@ 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 + "  " + event.model + "  \xB7  " + clip3(event.cwd, body - 30) + (event.authSource === "login" ? "  \xB7  subscription" : "") + S2.reset,
+        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 [S2.think + "  \xB7 thinking\u2026" + S2.reset];
-    case "assistant-message":
-      return ["", ...wrap(event.text, body).map((line) => S2.agent + "  " + line + S2.reset), ""];
+      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 glyph = GLYPH[event.kind] || GLYPH.other;
-      return [S2.tool + "  " + glyph + " " + S2.reset + S2.dim + clip3(event.target, body - 6) + S2.reset];
+      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 + "  \u26D4 blocked" + S2.reset + S2.dim + "  " + clip3(event.target, body - 14) + S2.reset,
-          ...wrap(event.reason, body - 6).map((line) => "     " + S2.rule + line + S2.reset)
+          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 mark = event.ok ? S2.ok + "  \u2713" : S2.blocked + "  \u2717";
-      const code = event.exitCode === null || event.exitCode === 0 ? "" : " (exit " + event.exitCode + ")";
-      const out = event.output.trim() ? S2.dim + "  " + clip3(event.output, body - 20) + S2.reset : "";
-      return [mark + S2.reset + code + out];
+      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 ["", S2.dim + "  " + (event.ok ? "done" : "ended with an error") + S2.reset, ""];
+      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:
@@ -16891,7 +17068,7 @@ function wrap(text, width) {
   if (line) lines.push(line);
   return lines;
 }
-var ESC2, S2, GLYPH;
+var ESC2, S2, CLEAR_LINE, BULLET, ELBOW, SPINNER, TOOL_LABEL;
 var init_render2 = __esm({
   "cli/harness/render.ts"() {
     "use strict";
@@ -16908,84 +17085,340 @@ var init_render2 = __esm({
       blocked: ESC2 + "38;5;203m",
       rule: ESC2 + "38;5;211m"
     };
-    GLYPH = {
-      shell: "\u276F",
-      read: "\u25C4",
-      edit: "\u270E",
-      write: "\u270E",
-      delete: "\u2716",
-      search: "\u2315",
-      list: "\u2630",
-      todo: "\u2611",
-      other: "\u2022"
+    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) {
+  switch (event.type) {
+    case "user-message":
+      return "u:" + event.text;
+    case "assistant-message":
+      return "a:" + event.text;
+    case "tool-start":
+      return "s:" + event.id;
+    case "tool-end":
+      return "e:" + event.id;
+    default:
+      return "";
+  }
+}
+function createTurnSink(opts) {
+  const events = [];
+  const now = opts.now || (() => Date.now());
+  const showPrompt = opts.showPrompt !== false;
+  let blocked = 0;
+  let replaying = false;
+  const seen = /* @__PURE__ */ new Set();
+  let sawTurnEnd = false;
+  let sawAnswer = false;
+  let buffer = "";
+  let reconnecting = false;
+  let lastWasAnswer = false;
+  let statusText = "";
+  let statusKind = "progress";
+  let statusShown = false;
+  let tick = 0;
+  const startedAt = now();
+  let timer = null;
+  const drawStatus = () => {
+    if (!opts.animate || !statusText) return;
+    opts.write(statusLine({
+      tick,
+      text: statusText,
+      elapsedMs: now() - startedAt,
+      width: opts.width,
+      hint: "ctrl-c to interrupt"
+    }));
+    statusShown = true;
+  };
+  const clearStatus = () => {
+    if (!statusShown) return;
+    opts.write(CLEAR_LINE);
+    statusShown = false;
+  };
+  const setStatus = (text, kind = "progress") => {
+    statusText = text;
+    statusKind = kind;
+    if (!opts.animate) return;
+    if (!timer) {
+      timer = setInterval(() => {
+        tick += 1;
+        clearStatus();
+        drawStatus();
+      }, TICK_MS);
+      timer.unref?.();
+    }
+    clearStatus();
+    drawStatus();
+  };
+  const stopStatus = () => {
+    statusText = "";
+    statusKind = "progress";
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    clearStatus();
+  };
+  let gaveUp = false;
+  let stall = null;
+  const graceMs = opts.postAnswerGraceMs ?? 15e3;
+  const disarmStall = () => {
+    if (stall) {
+      clearTimeout(stall);
+      stall = null;
+    }
+  };
+  const giveUp = () => {
+    if (gaveUp) return;
+    gaveUp = true;
+    disarmStall();
+    opts.onGiveUp?.();
+  };
+  const armStall = () => {
+    disarmStall();
+    stall = setTimeout(giveUp, graceMs);
+    stall.unref?.();
+  };
+  const settle = () => {
+    reconnecting = false;
+    if (statusKind === "retry") setStatus("Thinking");
+  };
+  const emit2 = (event) => {
+    events.push(event);
+    if (event.type === "tool-end" && event.blocked) blocked += 1;
+    opts.onEvent?.(event);
+    if (event.type === "notice" && event.kind === "retry") {
+      reconnecting = true;
+      if (sawAnswer && lastWasAnswer) {
+        setStatus("finishing up", "retry");
+        armStall();
+      } else {
+        setStatus(event.text, "retry");
+      }
+      return;
+    }
+    if (event.type === "thinking") {
+      if (!reconnecting) setStatus("Thinking");
+      return;
+    }
+    if (event.type === "user-message" && !showPrompt) return;
+    if (event.type === "session-start" && opts.showHeader === false) return;
+    if (event.type === "assistant-message" || event.type === "tool-end") settle();
+    if (event.type === "tool-start") {
+      reconnecting = false;
+      setStatus("Running " + event.kind);
+    }
+    if (event.type === "turn-end") stopStatus();
+    const rendered = renderEvent(event, opts.width);
+    if (!rendered.length) return;
+    clearStatus();
+    opts.write(rendered.join("\n") + "\n");
+    drawStatus();
+  };
+  const take = (event) => {
+    const isRetry = event.type === "notice" && event.kind === "retry";
+    if (!isRetry) disarmStall();
+    if (isRetry) {
+      if (reconnecting && sawAnswer && lastWasAnswer) {
+        giveUp();
+        return;
+      }
+      replaying = true;
+    }
+    const key = replayKey(event);
+    if (key) {
+      if (replaying && seen.has(key)) {
+        lastWasAnswer = event.type === "assistant-message";
+        settle();
+        return;
+      }
+      seen.add(key);
+    }
+    if (key || event.type === "thinking") lastWasAnswer = event.type === "assistant-message";
+    if (event.type === "turn-end") sawTurnEnd = true;
+    if (event.type === "assistant-message") sawAnswer = true;
+    emit2(event);
+  };
+  return {
+    chunk(text) {
+      const { lines, rest } = feed(buffer, text);
+      buffer = rest;
+      for (const line of lines) for (const event of parseCursorLine(line)) take(event);
+    },
+    notice(text) {
+      emit2({ type: "notice", text });
+    },
+    finish(exit, interrupted = false) {
+      disarmStall();
+      stopStatus();
+      if (!sawTurnEnd) {
+        if (interrupted) {
+          emit2({ type: "notice", text: "interrupted" });
+          emit2({ type: "turn-end", ok: true, text: "" });
+        } else {
+          if (exit !== 0 && !sawAnswer) {
+            emit2({ type: "notice", text: "cursor-agent exited " + exit + " without completing the turn" });
+          }
+          emit2({ type: "turn-end", ok: sawAnswer, text: "" });
+        }
+      }
+      stopStatus();
+      return { events, blocked, exitCode: interrupted ? 130 : sawAnswer ? 0 : exit };
+    }
+  };
+}
 async function runCursorTurn(opts) {
   const write2 = opts.write || ((text) => process.stdout.write(text));
   const width = opts.width || Number(process.stdout.columns || 100);
-  const events = [];
-  let blocked = 0;
-  let lastWasThinking = false;
+  let stopHarness = () => {
+  };
+  const sink = createTurnSink({
+    write: write2,
+    onEvent: opts.onEvent,
+    width,
+    animate: Boolean(process.stdout.isTTY),
+    showPrompt: opts.showPrompt,
+    showHeader: opts.showHeader,
+    onGiveUp: () => stopHarness()
+  });
   return new Promise((resolve7) => {
     const child = spawn9("cursor-agent", cursorArgs(opts.prompt), {
       cwd: opts.cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    let buffer = "";
-    child.stdout.on("data", (chunk) => {
-      const { lines, rest } = feed(buffer, chunk.toString("utf8"));
-      buffer = rest;
-      for (const line of lines) {
-        for (const event of parseCursorLine(line)) {
-          events.push(event);
-          if (event.type === "tool-end" && event.blocked) blocked += 1;
-          opts.onEvent?.(event);
-          if (event.type === "thinking") {
-            if (lastWasThinking) continue;
-            lastWasThinking = true;
-          } else {
-            lastWasThinking = false;
-          }
-          const rendered = renderEvent(event, width);
-          if (rendered.length) write2(rendered.join("\n") + "\n");
-        }
-      }
-    });
+    stopHarness = () => {
+      child.kill();
+      const hard = setTimeout(() => child.kill("SIGKILL"), 3e3);
+      hard.unref?.();
+      child.once("close", () => clearTimeout(hard));
+    };
+    let interrupted = false;
+    const onAbort = () => {
+      interrupted = true;
+      stopHarness();
+    };
+    if (opts.signal?.aborted) onAbort();
+    else opts.signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (chunk) => sink.chunk(chunk.toString("utf8")));
+    let lastNote = "";
     child.stderr.on("data", (chunk) => {
-      const text = chunk.toString("utf8").trim();
-      if (/error|fatal/i.test(text) && !/RetriableError/i.test(text)) {
-        write2(renderEvent({ type: "notice", text }, width).join("\n") + "\n");
+      const note = stderrNotice(chunk.toString("utf8"));
+      if (note && note !== lastNote) {
+        lastNote = note;
+        sink.notice(note);
       }
     });
     child.on("close", (code) => {
-      resolve7({ events, blocked, exitCode: code ?? 0 });
+      opts.signal?.removeEventListener("abort", onAbort);
+      resolve7(sink.finish(code ?? 0, interrupted));
     });
     child.on("error", (error) => {
-      write2(renderEvent({ type: "notice", text: "failed to start cursor-agent: " + String(error) }, width).join("\n") + "\n");
-      resolve7({ events, blocked, exitCode: 1 });
+      sink.notice("failed to start cursor-agent: " + String(error));
+      resolve7(sink.finish(1, interrupted));
     });
   });
 }
+var TICK_MS;
 var init_run = __esm({
   "cli/harness/run.ts"() {
     "use strict";
     init_cursor();
     init_render2();
+    TICK_MS = 120;
+  }
+});
+
+// cli/harness/identity.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import { homedir as homedir38 } from "os";
+function shortenPath(path, home = homedir38()) {
+  const value = String(path || "");
+  if (home && value === home) return "~";
+  if (home && value.startsWith(home + "/")) return "~" + value.slice(home.length);
+  return value;
+}
+function parseCursorAccount(output) {
+  const match = String(output || "").match(/logged in as\s+(\S+)/i);
+  return match ? match[1].trim() : "";
+}
+function cursorAccount() {
+  try {
+    const out = execFileSync5("cursor-agent", ["status"], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return parseCursorAccount(out);
+  } catch {
+    return "";
+  }
+}
+function synkroAccount() {
+  let email = "";
+  try {
+    email = String(getUserInfo().email || "");
+  } catch {
+    return { email: "", needsLogin: false };
+  }
+  let needsLogin = false;
+  try {
+    needsLogin = isTokenExpired() && !loadCredentials()?.refresh_token;
+  } catch {
+  }
+  return { email, needsLogin };
+}
+function readIdentity(harness) {
+  const synkro = synkroAccount();
+  return {
+    harness: harness === "cursor" ? cursorAccount() : "",
+    synkro: synkro.email,
+    needsLogin: synkro.needsLogin
+  };
+}
+function identityHeader(opts) {
+  const lines = ["", S2.bold + "  " + shortenPath(opts.cwd, opts.home) + S2.reset];
+  const label = (name, value, note = "") => S2.dim + "  " + name.padEnd(7) + S2.reset + S2.think + value + S2.reset + note;
+  if (opts.identity.harness) lines.push(label(opts.harness, opts.identity.harness));
+  if (opts.identity.synkro) {
+    lines.push(label("synkro", opts.identity.synkro, opts.identity.needsLogin ? S2.blocked + "  \xB7  session ended, run synkro login" + S2.reset : ""));
+  }
+  lines.push("");
+  return lines;
+}
+var init_identity2 = __esm({
+  "cli/harness/identity.ts"() {
+    "use strict";
+    init_auth();
+    init_render2();
   }
 });
 
 // cli/harness/session.ts
 import { createInterface as createInterface5 } from "readline";
-async function runOnce(harness, cwd, prompt) {
+async function runOnce(harness, cwd, prompt, echoPrompt = true, showHeader = true, signal) {
   if (harness !== "cursor") {
     process.stdout.write(S2.dim + "  " + harness + " sessions are not embedded yet\n" + S2.reset);
     return 1;
   }
-  const result = await runCursorTurn({ prompt, cwd });
+  const result = await runCursorTurn({ prompt, cwd, showPrompt: echoPrompt, showHeader, signal });
   if (result.blocked > 0) {
     process.stdout.write(
       S2.blocked + "  " + result.blocked + " action" + (result.blocked === 1 ? "" : "s") + " blocked by policy" + S2.reset + "\n"
@@ -16995,31 +17428,46 @@ async function runOnce(harness, cwd, prompt) {
 }
 async function runGovernedSession(harness, cwd, prompt) {
   if (prompt) return runOnce(harness, cwd, prompt);
-  process.stdout.write(BANNER.join("\n") + "\n");
+  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) => rl.question(S2.user + "  \u276F " + S2.reset, resolve7));
+  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);
+    });
+  });
+  let turn = null;
+  rl.on("SIGINT", () => {
+    if (turn) {
+      turn.abort();
+      return;
+    }
+    process.stdout.write("\n");
+    rl.close();
+  });
+  let first = true;
   for (; ; ) {
-    const line = (await ask3()).trim();
+    const answer = await ask3();
+    if (answer === null) break;
+    const line = answer.trim();
     if (!line) continue;
     if (line === "exit" || line === "quit") break;
-    await runOnce(harness, cwd, line);
+    turn = new AbortController();
+    await runOnce(harness, cwd, line, false, first, turn.signal);
+    turn = null;
+    first = false;
   }
   rl.close();
   return 0;
 }
-var BANNER;
 var init_session = __esm({
   "cli/harness/session.ts"() {
     "use strict";
     init_run();
+    init_identity2();
     init_render2();
-    BANNER = [
-      "",
-      S2.bold + "  synkro" + S2.reset + S2.dim + "  governed session" + S2.reset,
-      S2.dim + "  every tool call passes Synkro policy before it runs" + S2.reset,
-      S2.dim + "  ctrl-c to leave" + S2.reset,
-      ""
-    ];
   }
 });
 
@@ -17212,7 +17660,7 @@ __export(linear_exports, {
   linearCommand: () => linearCommand
 });
 import { readFileSync as readFileSync33 } from "fs";
-import { homedir as homedir38 } from "os";
+import { homedir as homedir39 } from "os";
 import { join as join37 } from "path";
 function mcpJwt() {
   try {
@@ -17255,7 +17703,7 @@ var SYNKRO_DIR14, PORT2, BASE;
 var init_linear = __esm({
   "cli/commands/linear.ts"() {
     "use strict";
-    SYNKRO_DIR14 = join37(homedir38(), ".synkro");
+    SYNKRO_DIR14 = join37(homedir39(), ".synkro");
     PORT2 = process.env.SYNKRO_MCP_PORT || "18931";
     BASE = `http://127.0.0.1:${PORT2}`;
   }
@@ -17404,10 +17852,10 @@ var init_cveReachability = __esm({
 });
 
 // cli/reachability/reachabilityScan.ts
-import { spawnSync as spawnSync12, execFileSync as execFileSync5 } from "child_process";
+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 homedir39 } from "os";
+import { homedir as homedir40 } 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"]);
@@ -17531,7 +17979,7 @@ function findEntries(repoRoot3) {
 }
 function currentCommit(repoRoot3) {
   try {
-    return execFileSync5("git", ["rev-parse", "HEAD"], { cwd: repoRoot3, encoding: "utf8" }).trim();
+    return execFileSync6("git", ["rev-parse", "HEAD"], { cwd: repoRoot3, encoding: "utf8" }).trim();
   } catch {
     return "";
   }
@@ -17655,7 +18103,7 @@ var init_reachabilityScan = __esm({
     "use strict";
     init_cveReachability();
     require2 = createRequire(import.meta.url);
-    REACHABILITY_PATH = join38(homedir39(), ".synkro", "reachability.json");
+    REACHABILITY_PATH = join38(homedir40(), ".synkro", "reachability.json");
   }
 });
 
@@ -17666,8 +18114,8 @@ __export(reachabilityScan_exports, {
 });
 import { readFileSync as readFileSync36, existsSync as existsSync39 } from "fs";
 import { join as join39 } from "path";
-import { homedir as homedir40 } from "os";
-import { execFileSync as execFileSync6 } from "child_process";
+import { homedir as homedir41 } from "os";
+import { execFileSync as execFileSync7 } from "child_process";
 function readConfigEnv4() {
   const p = join39(SYNKRO_DIR15, "config.env");
   if (!existsSync39(p)) return {};
@@ -17682,7 +18130,7 @@ function readConfigEnv4() {
 }
 function repoRoot2() {
   try {
-    return execFileSync6("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" }).trim();
+    return execFileSync7("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" }).trim();
   } catch {
     return process.cwd();
   }
@@ -17690,7 +18138,7 @@ function repoRoot2() {
 function repoSlug(root) {
   const run2 = (a) => {
     try {
-      return execFileSync6("git", a, { encoding: "utf-8" }).trim();
+      return execFileSync7("git", a, { encoding: "utf-8" }).trim();
     } catch {
       return "";
     }
@@ -17740,7 +18188,7 @@ var init_reachabilityScan2 = __esm({
   "cli/commands/reachabilityScan.ts"() {
     "use strict";
     init_reachabilityScan();
-    SYNKRO_DIR15 = join39(homedir40(), ".synkro");
+    SYNKRO_DIR15 = join39(homedir41(), ".synkro");
   }
 });
 
@@ -17872,7 +18320,7 @@ __export(config_exports, {
 });
 import { readFileSync as readFileSync37, writeFileSync as writeFileSync28, existsSync as existsSync40 } from "fs";
 import { join as join40 } from "path";
-import { homedir as homedir41 } from "os";
+import { homedir as homedir42 } from "os";
 function readConfigEnv5() {
   if (!existsSync40(CONFIG_PATH9)) return {};
   const out = {};
@@ -18058,7 +18506,7 @@ var init_config = __esm({
     "use strict";
     init_stub();
     init_optout();
-    SYNKRO_DIR16 = join40(homedir41(), ".synkro");
+    SYNKRO_DIR16 = join40(homedir42(), ".synkro");
     CONFIG_PATH9 = join40(SYNKRO_DIR16, "config.env");
   }
 });
@@ -18250,10 +18698,10 @@ 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 homedir42 } from "os";
+import { homedir as homedir43 } from "os";
 import { dirname as dirname12, join as join41 } from "path";
 function operationalIdentityPath() {
-  return process.env.SYNKRO_OPERATIONAL_IDENTITY_PATH || join41(homedir42(), ".synkro", "installation.json");
+  return process.env.SYNKRO_OPERATIONAL_IDENTITY_PATH || join41(homedir43(), ".synkro", "installation.json");
 }
 function validIdentity(value) {
   if (!value || typeof value !== "object") return false;
@@ -18285,7 +18733,7 @@ function getOperationalInstallationIdentity(path = operationalIdentityPath()) {
   return identity;
 }
 var UUID_RE, cached4;
-var init_identity2 = __esm({
+var init_identity3 = __esm({
   "cli/inventory/identity.ts"() {
     "use strict";
     UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -18301,7 +18749,7 @@ import {
   readdirSync as readdirSync11,
   statSync as statSync5
 } from "fs";
-import { arch, homedir as homedir43, hostname as hostname2, platform as platform6, release as release2 } from "os";
+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 { fileURLToPath } from "url";
 function sha256(value) {
@@ -18312,7 +18760,7 @@ function pseudonymousHostnameHash(installationId, host) {
 }
 function cliVersion() {
   try {
-    return "1.10.4";
+    return "1.10.6";
   } catch {
     return "0.0.0";
   }
@@ -18707,7 +19155,7 @@ function harnessSnapshot(agent) {
   };
 }
 function collectOperationalInventory(options = {}) {
-  const home = options.homeDir ?? homedir43();
+  const home = options.homeDir ?? homedir44();
   const detected = options.detectedAgents ?? detectAgents();
   const identity = getOperationalInstallationIdentity(options.identityPath);
   const targetPlatform = options.platformName ?? platform6();
@@ -18819,7 +19267,7 @@ var init_collector = __esm({
     init_ccHookConfig();
     init_cursorHookConfig();
     init_codexHookConfig();
-    init_identity2();
+    init_identity3();
   }
 });
 
@@ -18843,10 +19291,10 @@ import {
   renameSync as renameSync10,
   writeFileSync as writeFileSync30
 } from "fs";
-import { homedir as homedir44 } from "os";
+import { homedir as homedir45 } from "os";
 import { dirname as dirname13, join as join43 } from "path";
 function syncStatePath() {
-  return process.env.SYNKRO_INVENTORY_SYNC_STATE_PATH || join43(homedir44(), ".synkro", "inventory-sync.json");
+  return process.env.SYNKRO_INVENTORY_SYNC_STATE_PATH || join43(homedir45(), ".synkro", "inventory-sync.json");
 }
 function readState(path = syncStatePath()) {
   try {
@@ -18873,7 +19321,7 @@ function shouldSyncInventory(state, now = Date.now(), target) {
   return !Number.isFinite(lastAttempt) || lastAttempt <= 0 || now - lastAttempt >= FAILURE_RETRY_MS;
 }
 function readConfig() {
-  const path = join43(homedir44(), ".synkro", "config.env");
+  const path = join43(homedir45(), ".synkro", "config.env");
   const out = {};
   try {
     for (const rawLine of readFileSync40(path, "utf8").split("\n")) {
@@ -18915,7 +19363,7 @@ function resolveInventoryGateway(raw) {
 }
 async function loadToken() {
   try {
-    const durable = readFileSync40(join43(homedir44(), ".synkro", ".mcp-jwt"), "utf8").trim();
+    const durable = readFileSync40(join43(homedir45(), ".synkro", ".mcp-jwt"), "utf8").trim();
     if (durable) return durable;
   } catch {
   }
@@ -19082,7 +19530,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.4");
+  console.log("1.10.6");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents