@synkro-sh/cli 1.7.95 → 1.9.0

package/dist/bootstrap.js

@@ -145,9 +145,9 @@ function hostnameHash() {
 }
 function getIdentity() {
   if (cached2) return cached2;
-  let cliVersion = "0.0.0";
+  let cliVersion2 = "0.0.0";
   try {
-    cliVersion = "1.7.95";
+    cliVersion2 = "1.9.0";
   } catch {
   }
   const creds = loadCredentialsIdentity();
@@ -157,7 +157,7 @@ function getIdentity() {
     user_id: creds.user_id,
     org_id: creds.org_id,
     email: creds.email,
-    cli_version: cliVersion,
+    cli_version: cliVersion2,
     platform: platform(),
     hostname_hash: hostnameHash(),
     node_version: process.version,
@@ -183,8 +183,8 @@ import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2 } fr
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
 function deriveGit(cwd) {
-  const cached4 = gitCache.get(cwd);
-  if (cached4) return cached4;
+  const cached5 = gitCache.get(cwd);
+  if (cached5) return cached5;
   const info = { branch: null, sha: null };
   try {
     const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
@@ -234,7 +234,7 @@ function emit(eventType, context, opts) {
     const cwd = opts?.cwd ?? process.cwd();
     const git = deriveGit(cwd);
     const emitter = process.env.SYNKRO_TELEMETRY_EMITTER || "bootstrap";
-    const row = {
+    const row2 = {
       client_event_id: randomUUID2(),
       event_type: eventType,
       occurred_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -263,7 +263,7 @@ function emit(eventType, context, opts) {
       context: redactContext(context)
     };
     ensureDir2();
-    appendFileSync(PENDING_PATH, JSON.stringify(row) + "\n", { mode: 384 });
+    appendFileSync(PENDING_PATH, JSON.stringify(row2) + "\n", { mode: 384 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[synkro] telemetry emit(${eventType}) failed: ${msg}
@@ -297,9 +297,9 @@ function shiftPlaceholders(text, offset) {
 function bulkFragment(rows, columns) {
   if (!rows.length || !columns.length) throw new Error("empty SQL helper");
   const params = [];
-  const tuples = rows.map((row) => {
+  const tuples = rows.map((row2) => {
     const placeholders = columns.map((column) => {
-      let value = row[column];
+      let value = row2[column];
       let cast = "";
       if (column === "context" && typeof value === "object" && value !== null) {
         value = JSON.stringify(value);
@@ -1169,7 +1169,7 @@ async function getStats() {
       GROUP BY event_type
       ORDER BY c DESC
     `;
-    for (const row of types) base.by_type[String(row.event_type)] = Number(row.c);
+    for (const row2 of types) base.by_type[String(row2.event_type)] = Number(row2.c);
     const newest = await sql`
       SELECT occurred_at FROM telemetry_events ORDER BY occurred_at DESC LIMIT 1
     `;
@@ -1224,8 +1224,8 @@ async function exportEvents(path) {
   const lines = [];
   try {
     const rows = await sql`SELECT * FROM telemetry_events ORDER BY occurred_at ASC`;
-    for (const row of rows) {
-      lines.push(JSON.stringify(row));
+    for (const row2 of rows) {
+      lines.push(JSON.stringify(row2));
     }
   } catch {
   }
@@ -1777,6 +1777,27 @@ function uninstallCCHooks(settingsPath) {
   writeSettingsAtomic(settingsPath, settings);
   return true;
 }
+function inspectCCHooks(settingsPath) {
+  if (!existsSync11(settingsPath)) {
+    return { installed: false, preToolUseBash: false, postToolUseEdit: false, sessionEnd: false, sessionStart: false };
+  }
+  const settings = readSettings(settingsPath);
+  const pre = settings.hooks?.PreToolUse ?? [];
+  const post = settings.hooks?.PostToolUse ?? [];
+  const sessionEndHooks = settings.hooks?.SessionEnd ?? [];
+  const sessionStartHooks = settings.hooks?.SessionStart ?? [];
+  const preToolUseBash = pre.some((e) => e?.[SYNKRO_MARKER] === true);
+  const postToolUseEdit = post.some((e) => e?.[SYNKRO_MARKER] === true);
+  const sessionEnd = sessionEndHooks.some((e) => e?.[SYNKRO_MARKER] === true);
+  const sessionStart = sessionStartHooks.some((e) => e?.[SYNKRO_MARKER] === true);
+  return {
+    installed: preToolUseBash || postToolUseEdit || sessionEnd || sessionStart,
+    preToolUseBash,
+    postToolUseEdit,
+    sessionEnd,
+    sessionStart
+  };
+}
 var SYNKRO_MARKER, USAGE_PROXY_URL;
 var init_ccHookConfig = __esm({
   "cli/installer/ccHookConfig.ts"() {
@@ -1985,6 +2006,74 @@ function uninstallCursorHooks(hooksJsonPath) {
   writeHooksFileAtomic(hooksJsonPath, file);
   return true;
 }
+function preToolUseUsesScript(hooks, scriptBasename) {
+  return (hooks ?? []).some(
+    (e) => isSynkroEntry2(e) && typeof e.command === "string" && e.command.includes(scriptBasename)
+  );
+}
+function inspectCursorHooks(hooksJsonPath) {
+  let file;
+  try {
+    file = readHooksFile(hooksJsonPath);
+  } catch {
+    return {
+      installed: false,
+      sessionStart: false,
+      sessionEnd: false,
+      beforeSubmitPrompt: false,
+      stop: false,
+      beforeShellExecution: false,
+      afterShellExecution: false,
+      preToolUse: false,
+      preToolUseBash: false,
+      preToolUseEdit: false,
+      preToolUseCwe: false,
+      preToolUseCve: false,
+      preToolUseAgent: false,
+      preToolUsePlan: false,
+      afterFileEdit: false,
+      postToolUse: false,
+      beforeMCPExecution: false
+    };
+  }
+  const h = file.hooks ?? {};
+  const sessionStart = (h.sessionStart ?? []).some((e) => isSynkroEntry2(e));
+  const sessionEnd = (h.sessionEnd ?? []).some((e) => isSynkroEntry2(e));
+  const beforeSubmitPrompt = (h.beforeSubmitPrompt ?? []).some((e) => isSynkroEntry2(e));
+  const stop = (h.stop ?? []).some((e) => isSynkroEntry2(e));
+  const beforeShellExecution = (h.beforeShellExecution ?? []).some((e) => isSynkroEntry2(e));
+  const afterShellExecution = (h.afterShellExecution ?? []).some((e) => isSynkroEntry2(e));
+  const pre = h.preToolUse ?? [];
+  const preToolUseBash = preToolUseUsesScript(pre, "cc-bash-judge") || preToolUseUsesScript(pre, "cursor-bash-judge");
+  const preToolUseEdit = preToolUseUsesScript(pre, "cc-edit-precheck") || preToolUseUsesScript(pre, "cursor-edit-precheck");
+  const preToolUseCwe = preToolUseUsesScript(pre, "cc-cwe-precheck");
+  const preToolUseCve = preToolUseUsesScript(pre, "cc-cve-precheck");
+  const preToolUseAgent = preToolUseUsesScript(pre, "cc-agent-judge");
+  const preToolUsePlan = preToolUseUsesScript(pre, "cc-plan-judge");
+  const preToolUse = preToolUseBash || preToolUseEdit || preToolUseCwe || preToolUseCve || preToolUseAgent || preToolUsePlan;
+  const afterFileEdit = (h.afterFileEdit ?? []).some((e) => isSynkroEntry2(e));
+  const postToolUse = (h.postToolUse ?? []).some((e) => isSynkroEntry2(e));
+  const beforeMCPExecution = (h.beforeMCPExecution ?? []).some((e) => isSynkroEntry2(e));
+  return {
+    installed: sessionStart || sessionEnd || beforeSubmitPrompt || stop || beforeShellExecution || afterShellExecution || preToolUse || afterFileEdit || postToolUse || beforeMCPExecution,
+    sessionStart,
+    sessionEnd,
+    beforeSubmitPrompt,
+    stop,
+    beforeShellExecution,
+    afterShellExecution,
+    preToolUse,
+    preToolUseBash,
+    preToolUseEdit,
+    preToolUseCwe,
+    preToolUseCve,
+    preToolUseAgent,
+    preToolUsePlan,
+    afterFileEdit,
+    postToolUse,
+    beforeMCPExecution
+  };
+}
 var SYNKRO_MARKER2, ALLOWED_PARENT_DIRS, ALL_EVENTS;
 var init_cursorHookConfig = __esm({
   "cli/installer/cursorHookConfig.ts"() {
@@ -2128,6 +2217,52 @@ function uninstallCodexHooks(hooksJsonPath) {
   writeHooksFileAtomic2(hooksJsonPath, file);
   return true;
 }
+function inspectCodexHooks(hooksJsonPath) {
+  let file;
+  try {
+    file = readHooksFile2(hooksJsonPath);
+  } catch {
+    return {
+      installed: false,
+      preToolUse: false,
+      preToolUseEdit: false,
+      preToolUseCwe: false,
+      preToolUseCve: false,
+      postToolUse: false,
+      postToolUseEdit: false,
+      sessionStart: false,
+      sessionEnd: false
+    };
+  }
+  const h = file.hooks ?? {};
+  const preToolUse = (h.PreToolUse ?? []).some((e) => isSynkroEntry3(e));
+  const editEntries = (h.PreToolUse ?? []).filter(
+    (e) => typeof e?.matcher === "string" && (e.matcher.includes("apply_patch") || e.matcher.includes("ApplyPatch") || e.matcher.includes("Edit"))
+  );
+  const entryUsesScript = (needle) => editEntries.some(
+    (entry) => (entry.hooks ?? []).some((handler) => String(handler?.command || "").includes(needle))
+  );
+  const preToolUseEdit = entryUsesScript("cc-edit-precheck");
+  const preToolUseCwe = entryUsesScript("cc-cwe-precheck");
+  const preToolUseCve = entryUsesScript("cc-cve-precheck");
+  const postToolUse = (h.PostToolUse ?? []).some((e) => isSynkroEntry3(e));
+  const postToolUseEdit = (h.PostToolUse ?? []).some(
+    (entry) => entry.matcher === CODEX_EDIT_MATCHER && (entry.hooks ?? []).some((handler) => String(handler?.command || "").includes("cc-edit-followup"))
+  );
+  const sessionStart = (h.SessionStart ?? []).some((e) => isSynkroEntry3(e));
+  const sessionEnd = (h.SessionEnd ?? []).some((e) => isSynkroEntry3(e));
+  return {
+    installed: preToolUseEdit && preToolUseCwe && preToolUseCve && postToolUseEdit,
+    preToolUse,
+    preToolUseEdit,
+    preToolUseCwe,
+    preToolUseCve,
+    postToolUse,
+    postToolUseEdit,
+    sessionStart,
+    sessionEnd
+  };
+}
 var SYNKRO_MARKER3, CODEX_BASH_MATCHER, M_BASH, CODEX_EDIT_MATCHER, M_EDIT, M_AGENT, M_MCP, M_ACTIVATE, ALL_EVENTS2;
 var init_codexHookConfig = __esm({
   "cli/installer/codexHookConfig.ts"() {
@@ -2189,7 +2324,7 @@ function buildCodexHookTrustEdits(hooks) {
   return [...edits.values()];
 }
 function queryCodexHookTrust(codexBinary = "codex", cwd = process.cwd(), autoTrust = false) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let settled = false;
     let stdout = "";
     let pending = "";
@@ -2207,7 +2342,7 @@ function queryCodexHookTrust(codexBinary = "codex", cwd = process.cwd(), autoTru
         child.kill();
       } catch {
       }
-      resolve6(summary);
+      resolve7(summary);
     };
     const timer = setTimeout(() => finish(null), 1e4);
     try {
@@ -2745,8 +2880,8 @@ Print a short readiness summary: rules now active, security scanning on, the gra
 // cli/installer/skillParser.ts
 import { existsSync as existsSync15 } from "fs";
 import { resolve as resolve3 } from "path";
-function resolveSkillPaths(skills, repoRoot2) {
-  return skills.filter((s) => s.endsWith(".md")).map((s) => resolve3(repoRoot2, s)).filter((p) => existsSync15(p));
+function resolveSkillPaths(skills, repoRoot3) {
+  return skills.filter((s) => s.endsWith(".md")).map((s) => resolve3(repoRoot3, s)).filter((p) => existsSync15(p));
 }
 var init_skillParser = __esm({
   "cli/installer/skillParser.ts"() {
@@ -2762,10 +2897,10 @@ var STUB_COMMON_TS, STUB_EDIT_PRECHECK_TS, STUB_EDIT_FOLLOWUP_TS, STUB_CWE_PRECH
 var init_hookScriptsTs = __esm({
   "cli/installer/hookScriptsTs.ts"() {
     "use strict";
-    STUB_COMMON_TS = String.raw`import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync, appendFileSync, statSync, realpathSync, openSync, readSync, closeSync } from 'node:fs';
-import { execSync } from 'node:child_process';
+    STUB_COMMON_TS = String.raw`import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync, appendFileSync, statSync, realpathSync, openSync, readSync, closeSync, unlinkSync } from 'node:fs';
+import { execFileSync, execSync } from 'node:child_process';
 import { homedir } from 'node:os';
-import { basename, join, resolve, relative, isAbsolute } from 'node:path';
+import { basename, dirname, join, resolve, relative, isAbsolute } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
 
 const HOME = homedir();
@@ -3001,6 +3136,650 @@ function gitRoot(cwd: string): string {
   } catch { return ''; }
 }
 
+// synkro.toml is per-machine and untracked, so a LINKED git worktree never has
+// its own copy — its root is a fresh checkout. Resolve the main checkout through
+// the worktree's .git pointer file (a linked worktree's .git is a FILE reading
+// "gitdir: <main>/.git/worktrees/<name>") so worktrees inherit the repo's
+// config instead of silently skipping all grading. Opt-in semantics survive: a
+// repo whose MAIN root has no synkro.toml stays dormant. Pure fs — no
+// subprocess on the hook hot path.
+function mainWorktreeRoot(root: string): string {
+  try {
+    const dotGit = join(root, '.git');
+    if (statSync(dotGit).isDirectory()) return root;
+    const pointer = readFileSync(dotGit, 'utf-8');
+    const match = pointer.match(/^gitdir:\s*(.+?)\s*$/m);
+    if (!match) return root;
+    const gitDir = isAbsolute(match[1]) ? match[1] : join(root, match[1]);
+    const marker = join('.git', 'worktrees') + '/';
+    const at = gitDir.lastIndexOf('/' + marker);
+    if (at === -1) return root;
+    return gitDir.slice(0, at) || root;
+  } catch { return root; }
+}
+
+function taskRepoContext(root: string): any {
+  if (!root) return undefined;
+  try {
+    const run = (args: string[]) => execFileSync('git', args, {
+      cwd: root,
+      timeout: 2000,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    const branch = run(['rev-parse', '--abbrev-ref', 'HEAD']);
+    const sha = run(['rev-parse', 'HEAD']);
+    const remote = run(['remote', 'get-url', 'origin']);
+    if (!branch || !sha || !remote) return undefined;
+    let baseBranch = branch === 'HEAD' ? '' : branch;
+    let baseSha = sha;
+    try {
+      const remoteHead = run(['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD']);
+      if (remoteHead.startsWith('origin/')) {
+        baseBranch = remoteHead.slice('origin/'.length);
+        baseSha = run(['rev-parse', remoteHead]);
+      }
+    } catch {}
+    if (!baseBranch || baseBranch === branch) {
+      for (const candidate of ['main', 'master']) {
+        try {
+          let candidateSha = '';
+          try { candidateSha = run(['rev-parse', '--verify', 'refs/remotes/origin/' + candidate]); }
+          catch { candidateSha = run(['rev-parse', '--verify', 'refs/heads/' + candidate]); }
+          if (candidateSha) {
+            baseBranch = candidate;
+            baseSha = candidateSha;
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    if (!baseBranch || !baseSha) return undefined;
+    let worktree = false;
+    try { worktree = statSync(join(root, '.git')).isFile(); } catch {}
+    const commonRoot = sharedRepoRoot(root);
+    return { root, commonRoot, remote, branch, sha, baseBranch, baseSha, worktree };
+  } catch { return undefined; }
+}
+
+// One task-workspace message per TOOL CALL, not per hook. A single Bash call fans
+// out to install-scan + bash-judge + skill-judge (an Edit fans out to four), and
+// every hook is its own process, so the dedupe has to live on disk rather than in
+// a Map the way the server-side status-line dedupe does (see stableHookEventIdentity
+// in scanning/scanRouter). Atomic first-writer-wins via an exclusive create: the
+// hook that wins says it in full, the rest stay terse.
+const TOOL_CALL_MARK_DIR = join(HOME, '.synkro', 'tool-call-marks');
+const TOOL_CALL_MARK_WINDOW_MS = 15000;
+
+function pruneToolCallMarks(now: number): void {
+  try {
+    const entries = readdirSync(TOOL_CALL_MARK_DIR);
+    if (entries.length < 200) return;
+    for (const name of entries) {
+      const path = join(TOOL_CALL_MARK_DIR, name);
+      try {
+        if (now - statSync(path).mtimeMs > TOOL_CALL_MARK_WINDOW_MS) unlinkSync(path);
+      } catch {}
+    }
+  } catch {}
+}
+
+// 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.
+const WORKSPACE_CHOICE_DIR = join(HOME, '.synkro', 'workspace-choice');
+
+// 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,
+// and on a machine where PATH shadows the binary (observed: a venv python
+// named synkro, and an older global without the command) that spelling cannot
+// succeed, which deadlocked the ask. Patterns are DIRECTIVES, never
+// questions: a trailing question mark rejects, and the bare verb matches only
+// as a short standalone reply. Callers gate on a PENDING ask, so ordinary
+// conversation containing "stay" is never scanned against this.
+function isWorkspaceStayIntent(prompt: string): boolean {
+  const normalized = String(prompt || '').toLowerCase().replace(/\s+/g, ' ').trim();
+  if (!normalized || normalized.length > 240) return false;
+  if (/\?\s*$/.test(normalized)) return false;
+  if (/^(?:yes[,.\s]+)?(?:please\s+)?stay(?:\s+(?:here|put))?(?:\s*(?:pls|please))?[.!]?$/.test(normalized)) return true;
+  return [
+    /\b(?:stay|remain|keep working|keep going|continue)\b[^?]{0,60}\b(?:current|same|this)\s+(?:worktree|workspace|checkout|directory)\b/,
+    /\b(?:do not|don't|dont|no need to)\s+(?:move|switch|change)\b[^?]{0,40}\b(?:worktrees?|workspaces?|checkouts?)\b/,
+  ].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; }
+}
+
+// Our own context string, so the shape is stable: '... task=<id> ...'.
+function taskIdFromScmContext(context: string): string {
+  const marker = ' task=';
+  const at = String(context || '').indexOf(marker);
+  if (at === -1) return '';
+  const rest = context.slice(at + marker.length);
+  const end = rest.indexOf(' ');
+  return (end === -1 ? rest : rest.slice(0, end)).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;
+  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;
+}
+
+function firstHookForToolCall(sessionId: string, payload: any): boolean {
+  const p = payload && typeof payload === 'object' ? payload : {};
+  const id = String(p.tool_use_id || p.tool_call_id || p.call_id || p.event_id || '').trim();
+  // Fallback when the harness omits a call id: tool name + input is identical across
+  // the surfaces of one call and distinct across different calls. Identical
+  // back-to-back commands can collide inside the window, which costs one repeated
+  // line and nothing else.
+  const material = id || (String(p.tool_name || '') + ':' + (p.tool_input ? JSON.stringify(p.tool_input) : ''));
+  if (!sessionId || !material) return true;
+  const key = createHash('sha256').update(sessionId + '\0' + material).digest('hex').slice(0, 24);
+  const marker = join(TOOL_CALL_MARK_DIR, key);
+  const now = Date.now();
+  try { mkdirSync(TOOL_CALL_MARK_DIR, { recursive: true }); } catch {}
+  pruneToolCallMarks(now);
+  try {
+    writeFileSync(marker, '', { flag: 'wx', mode: 0o600 });
+    return true;
+  } catch (err: any) {
+    if (err && err.code === 'EEXIST') {
+      // Outside the burst window this is a genuinely new call reusing the fallback
+      // key, so re-arm the marker and let it speak.
+      try {
+        if (now - statSync(marker).mtimeMs > TOOL_CALL_MARK_WINDOW_MS) {
+          writeFileSync(marker, '', { mode: 0o600 });
+          return true;
+        }
+      } catch {}
+      return false;
+    }
+    // Any other failure (read-only home, quota) must not silence the message.
+    return true;
+  }
+}
+
+function taskScmBlockResponse(harness: string, reason: string, verbose = true): string {
+  // Every fanned-out hook still denies — suppressing the decision itself would let the
+  // tool through if the winning hook's response were ever dropped. Only the TEXT
+  // collapses: the later surfaces of one tool call deny with no systemMessage and no
+  // additionalContext, so the transcript carries one workspace message, not three.
+  const tag = synkroOriginTag('synkro:scm', harness);
+  const message = tag + ' ' + reason;
+  if (harness === 'cursor') {
+    return verbose
+      ? JSON.stringify({ permission: 'deny', user_message: message, agent_message: message })
+      : JSON.stringify({ permission: 'deny', user_message: '', agent_message: '' });
+  }
+  if (!verbose) {
+    return JSON.stringify({
+      systemMessage: '',
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        // Only surfaces if this hook's denial is the one the harness reports.
+        permissionDecisionReason: tag + ' blocked — see the workspace message above',
+        additionalContext: '',
+      },
+    });
+  }
+  return JSON.stringify({
+    systemMessage: message,
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: message,
+      additionalContext: message,
+    },
+  });
+}
+
+function safeTaskBranch(value: string): boolean {
+  return /^[a-z][a-z0-9]*-[0-9]+\/[a-z0-9][a-z0-9-]{0,47}$/.test(value);
+}
+
+function gitOutput(root: string, args: string[], timeout = 5000): string {
+  return execFileSync('git', args, {
+    cwd: root,
+    timeout,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+}
+
+function gitSucceeds(root: string, args: string[]): boolean {
+  try { execFileSync('git', args, { cwd: root, timeout: 5000, stdio: 'ignore' }); return true; }
+  catch { return false; }
+}
+
+function samePath(left: string, right: string): boolean {
+  try { return realpathSync(left) === realpathSync(right); }
+  catch { return resolve(left) === resolve(right); }
+}
+
+function sharedRepoRoot(root: string): string {
+  const raw = gitOutput(root, ['rev-parse', '--git-common-dir']);
+  const common = resolve(root, raw);
+  if (basename(common) !== '.git') {
+    throw new Error('task worktrees require a non-bare repository with shared Git metadata');
+  }
+  return dirname(common);
+}
+
+// Claude Code only permits switching BETWEEN worktrees when the target lives under
+// <repo>/.claude/worktrees, so a cc session that activates a second task can never
+// reach another .synkro-worktrees path. Provisioning cc task worktrees under
+// .claude/worktrees keeps mid-session task switching working; every other harness
+// keeps the original location.
+const CC_MANAGED_WORKTREE_DIR = join('.claude', 'worktrees');
+const LEGACY_MANAGED_WORKTREE_DIR = '.synkro-worktrees';
+
+function managedWorktreeDir(harness: string): string {
+  return harness === 'cc' ? CC_MANAGED_WORKTREE_DIR : LEGACY_MANAGED_WORKTREE_DIR;
+}
+
+function taskWorktreePath(root: string, taskId: string, harness: string): string {
+  return join(sharedRepoRoot(root), managedWorktreeDir(harness), taskId);
+}
+
+function taskWorktreeCandidatePaths(root: string, taskId: string): string[] {
+  const shared = sharedRepoRoot(root);
+  return [CC_MANAGED_WORKTREE_DIR, LEGACY_MANAGED_WORKTREE_DIR]
+    .map((dir) => join(shared, dir, taskId));
+}
+
+// A task bound before the cc relocation keeps the worktree it already owns: the
+// canonical branch is checked out there, so provisioning a second one would fail
+// on 'the canonical task branch already exists in another workspace'.
+function resolveTaskWorktreePath(root: string, taskId: string, harness: string): string {
+  const records = taskWorktreeRecords(root);
+  const registered = taskWorktreeCandidatePaths(root, taskId)
+    .find((candidate) => records.some((item) => samePath(item.path, candidate)));
+  return registered || taskWorktreePath(root, taskId, harness);
+}
+
+function codexDesktopOrigin(): boolean {
+  const origin = String(process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE || '').toLowerCase();
+  const bundle = String(process.env.__CFBundleIdentifier || '').toLowerCase();
+  return origin === 'codex desktop' || bundle === 'com.openai.codex';
+}
+
+function ignoreManagedWorktreeDirectory(root: string, worktreePath: string): void {
+  const shared = sharedRepoRoot(root);
+  const common = join(shared, '.git');
+  const excludePath = join(common, 'info', 'exclude');
+  // Ignore the directory the worktree actually landed in, which differs per harness.
+  const entry = relative(shared, dirname(worktreePath)) + '/';
+  if (entry.startsWith('..')) return;
+  let existing = '';
+  try { existing = readFileSync(excludePath, 'utf-8'); } catch {}
+  if (existing.split(/\r?\n/).includes(entry)) return;
+  mkdirSync(dirname(excludePath), { recursive: true });
+  appendFileSync(excludePath, (existing && !existing.endsWith('\n') ? '\n' : '') + entry + '\n');
+}
+
+interface TaskWorktreeRecord { path: string; branch: string }
+
+function taskWorktreeRecords(root: string): TaskWorktreeRecord[] {
+  const records: TaskWorktreeRecord[] = [];
+  let current: TaskWorktreeRecord = { path: '', branch: '' };
+  const flush = () => {
+    if (current.path) records.push(current);
+    current = { path: '', branch: '' };
+  };
+  for (const line of (gitOutput(root, ['worktree', 'list', '--porcelain']) + '\n').split('\n')) {
+    if (!line) { flush(); continue; }
+    if (line.startsWith('worktree ')) current.path = line.slice('worktree '.length);
+    else if (line.startsWith('branch refs/heads/')) current.branch = line.slice('branch refs/heads/'.length);
+  }
+  return records;
+}
+
+function gitOperationInProgress(root: string): boolean {
+  if (gitSucceeds(root, ['rev-parse', '--verify', '--quiet', 'MERGE_HEAD'])) return true;
+  for (const state of ['rebase-merge', 'rebase-apply']) {
+    try {
+      const raw = gitOutput(root, ['rev-parse', '--git-path', state]);
+      const path = isAbsolute(raw) ? raw : resolve(root, raw);
+      if (existsSync(path)) return true;
+    } catch {}
+  }
+  return false;
+}
+
+function validateTaskWorktree(root: string, currentRoot: string, op: any): string {
+  // Accept either managed location: a task bound before the cc relocation still
+  // pushes from its legacy .synkro-worktrees path.
+  const expected = taskWorktreeCandidatePaths(root, String(op.taskId || ''));
+  const supplied = String(op.worktreePath || '');
+  const managed = Boolean(supplied) && expected.some((candidate) => samePath(supplied, candidate));
+  const nativeCurrent = Boolean(supplied) && samePath(supplied, currentRoot);
+  if (!managed && !nativeCurrent) {
+    throw new Error('task worktree path does not match the managed or current native workspace');
+  }
+  const record = taskWorktreeRecords(root).find((item) => samePath(item.path, supplied));
+  if (!record || record.branch !== String(op.branchName || '')) {
+    throw new Error('task worktree is stale or no longer owns the canonical branch');
+  }
+  if (gitOutput(supplied, ['rev-parse', '--abbrev-ref', 'HEAD']) !== String(op.branchName || '')) {
+    throw new Error('task worktree is not on the canonical branch');
+  }
+  return supplied;
+}
+
+async function completeTaskScm(sessionId: string, op: any, ok: boolean, error: string, worktreePath: string): Promise<void> {
+  try {
+    await fetch('http://127.0.0.1:' + PORT + '/api/local/task-scm/complete', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + loadMcpJwt() },
+      body: JSON.stringify({ taskId: op.taskId, sessionId, kind: op.kind, ok, error, worktreePath }),
+      signal: AbortSignal.timeout(5000),
+    });
+  } catch {}
+}
+
+function executeTaskScm(root: string, op: any, harness: string): string {
+  if (!op || typeof op !== 'object') throw new Error('invalid SCM operation');
+  if (!/^task_[a-z0-9]{8}$/i.test(String(op.taskId || ''))) throw new Error('invalid task id');
+  const branch = String(op.branchName || '');
+  if (!safeTaskBranch(branch)) throw new Error('invalid canonical task branch');
+  const boundRoot = String(op.repoRoot || '');
+  if (!boundRoot || (!samePath(boundRoot, root) && !samePath(sharedRepoRoot(boundRoot), sharedRepoRoot(root)))) {
+    throw new Error('task workspace does not match this repository');
+  }
+
+  if (op.kind === 'branch') {
+    if (op.prepareHandoffBranch === true) {
+      if (gitOperationInProgress(root)) {
+        throw new Error('finish the active merge or rebase before task automation');
+      }
+      const originalBranch = gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']);
+      const head = gitOutput(root, ['rev-parse', 'HEAD']);
+      if (!op.startSha || head !== String(op.startSha)) {
+        throw new Error('Codex local checkout HEAD does not match the task creation revision');
+      }
+      if (gitSucceeds(boundRoot, ['show-ref', '--verify', '--quiet', 'refs/heads/' + branch])) {
+        throw new Error('the canonical task branch already exists in another workspace');
+      }
+      if (!op.baseSha || !gitSucceeds(boundRoot, ['cat-file', '-e', String(op.baseSha) + '^{commit}'])) {
+        throw new Error('task base revision is unavailable in this repository');
+      }
+      gitOutput(root, ['branch', branch, String(op.baseSha)], 30000);
+      if (gitOutput(root, ['rev-parse', 'HEAD']) !== head
+          || gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']) !== originalBranch) {
+        throw new Error('Git changed the shared checkout while reserving the task branch');
+      }
+      return '';
+    }
+    if (op.adoptExistingWorktree === true) {
+      const supplied = String(op.worktreePath || '');
+      if (!supplied || !samePath(root, supplied)) {
+        throw new Error('Codex native worktree does not match the current session workspace');
+      }
+      const record = taskWorktreeRecords(boundRoot).find((item) => samePath(item.path, root));
+      if (!record) throw new Error('Codex native worktree is not registered with Git');
+      if (gitOperationInProgress(root)) {
+        throw new Error('finish the active merge or rebase before task automation');
+      }
+      if (gitOutput(root, ['status', '--porcelain'])) {
+        throw new Error('Codex native worktree must be clean before it can be assigned to a new task');
+      }
+      const head = gitOutput(root, ['rev-parse', 'HEAD']);
+      if (!op.startSha || head !== String(op.startSha)) {
+        throw new Error('Codex native worktree HEAD does not match the task creation revision');
+      }
+      const currentBranch = gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']);
+      if (currentBranch !== branch) {
+        if (gitSucceeds(boundRoot, ['show-ref', '--verify', '--quiet', 'refs/heads/' + branch])) {
+          throw new Error('the canonical task branch already exists in another workspace');
+        }
+        if (!op.baseSha || !gitSucceeds(boundRoot, ['cat-file', '-e', String(op.baseSha) + '^{commit}'])) {
+          throw new Error('task base revision is unavailable in this repository');
+        }
+        gitOutput(root, ['switch', '-c', branch, String(op.baseSha)], 30000);
+      }
+      if (gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']) !== branch) {
+        throw new Error('Codex native worktree did not adopt the canonical task branch');
+      }
+      return root;
+    }
+    const worktreePath = resolveTaskWorktreePath(boundRoot, String(op.taskId), harness);
+    const existing = taskWorktreeRecords(boundRoot).find((item) => samePath(item.path, worktreePath));
+    if (existing) {
+      if (existing.branch !== branch || gitOutput(worktreePath, ['rev-parse', '--abbrev-ref', 'HEAD']) !== branch) {
+        throw new Error('managed task worktree exists on a conflicting branch');
+      }
+      return worktreePath;
+    }
+    if (existsSync(worktreePath)) {
+      throw new Error('managed task worktree path exists but is not registered with Git');
+    }
+    if (gitOperationInProgress(root)) {
+      throw new Error('finish the active merge or rebase before task automation');
+    }
+    const head = gitOutput(root, ['rev-parse', 'HEAD']);
+    if (!op.startSha || head !== String(op.startSha)) {
+      throw new Error('repository HEAD changed after task creation');
+    }
+    if (gitSucceeds(root, ['show-ref', '--verify', '--quiet', 'refs/heads/' + branch])) {
+      throw new Error('the canonical task branch already exists in another workspace');
+    }
+    if (!op.baseSha) throw new Error('task base revision is missing');
+    if (!gitSucceeds(root, ['cat-file', '-e', String(op.baseSha) + '^{commit}'])) {
+      throw new Error('task base revision is unavailable in this repository');
+    }
+    const originalBranch = gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    ignoreManagedWorktreeDirectory(boundRoot, worktreePath);
+    mkdirSync(dirname(worktreePath), { recursive: true });
+    gitOutput(root, ['worktree', 'add', '-b', branch, worktreePath, String(op.baseSha)], 30000);
+    if (gitOutput(root, ['rev-parse', 'HEAD']) !== head
+        || gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']) !== originalBranch) {
+      throw new Error('Git changed the originating checkout while creating the task worktree');
+    }
+    const record = taskWorktreeRecords(boundRoot).find((item) => samePath(item.path, worktreePath));
+    if (!record || record.branch !== branch
+        || gitOutput(worktreePath, ['rev-parse', '--abbrev-ref', 'HEAD']) !== branch) {
+      throw new Error('Git did not register the canonical task worktree');
+    }
+    return worktreePath;
+  }
+
+  if (op.kind !== 'push') throw new Error('unknown SCM operation');
+  const worktreePath = validateTaskWorktree(boundRoot, root, op);
+  if (gitOperationInProgress(worktreePath)) {
+    throw new Error('finish the active merge or rebase in the task worktree before pushing');
+  }
+  if (gitOutput(worktreePath, ['status', '--porcelain'])) {
+    gitOutput(worktreePath, ['add', '-A']);
+    if (!gitSucceeds(worktreePath, ['diff', '--cached', '--quiet'])) {
+      gitOutput(worktreePath, ['commit', '-m', String(op.commitMessage || 'Synkro task')], 30000);
+    }
+  }
+  gitOutput(worktreePath, ['push', '-u', 'origin', branch], 60000);
+  return worktreePath;
+}
+
+interface TaskScmReconcileResult { reason: string; context: string }
+
+// Who acted and where it ran: a message in a shared terminal should say which
+// harness produced it and whether this install is grading locally or in the cloud.
+function synkroOriginTag(prefix: string, harness: string): string {
+  return '[' + prefix
+    + (harness ? ':' + harness : '')
+    + ':' + (deployIsCloud() ? 'cloud' : 'local')
+    + ']';
+}
+
+function taskScmWorkspaceContext(workspace: any, harness = ''): string {
+  if (!workspace || typeof workspace !== 'object') return '';
+  const taskId = String(workspace.taskId || '');
+  const linearRef = String(workspace.linearRef || '');
+  const branchName = String(workspace.branchName || '');
+  const worktreePath = String(workspace.worktreePath || '');
+  if (!taskId || !branchName) return '';
+  return synkroOriginTag('synkro:task-workspace', harness) + ' task=' + taskId
+    + (linearRef ? ' linear=' + linearRef : '')
+    + ' branch=' + branchName
+    + (worktreePath ? ' worktree=' + worktreePath : ' worktree=pending-native-handoff');
+}
+
+function shellTaskWorkspaceArg(value: string): string {
+  return "'" + value.replace(/'/g, "'\"'\"'") + "'";
+}
+
+function taskScmWorkspaceInstruction(harness: string, sessionId: string, workspace: any): string {
+  const context = taskScmWorkspaceContext(workspace, harness);
+  const worktreePath = String(workspace?.worktreePath || '');
+  const branchName = String(workspace?.branchName || '');
+  if (!context || !branchName) return '';
+  const requirement = 'Do not continue in the shared checkout, use a per-command workdir, prefix commands with cd, '
+    + 'or ask the user to perform the transition. Synkro keeps substantive tools blocked until this exact session reports '
+    + 'the task worktree and canonical branch.';
+  if (harness === 'cc') {
+    if (!worktreePath) return context + '\nTask worktree creation failed closed; retry workspace preparation.';
+    // 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 '
+      + JSON.stringify(worktreePath) + ' on branch ' + JSON.stringify(branchName)
+      + ', or keep working in the current workspace. Do not decide for them. '
+      + 'To move: invoke EnterWorktree on that path. '
+      + 'To stay: run "synkro workspace stay ' + String(workspace?.taskId || '') + '".';
+  }
+  if (harness === 'cursor') {
+    if (!worktreePath) return context + '\n[synkro:workspace-handoff] Task worktree creation failed closed; retry workspace preparation.';
+    return context + '\n[synkro:workspace-handoff] Resume this exact Cursor chat in the existing task worktree now: cursor-agent --resume '
+      + shellTaskWorkspaceArg(sessionId) + ' --workspace ' + shellTaskWorkspaceArg(worktreePath)
+      + '. 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 + '\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;
+}
+
+function withTaskScmContext(responseText: string, harness: string, context: string): string {
+  if (!context) return responseText;
+  try {
+    const response = JSON.parse(responseText || '{}') as any;
+    if (harness === 'cursor') {
+      response.agent_message = [response.agent_message, context].filter(Boolean).join('\n');
+      return JSON.stringify(response);
+    }
+    response.systemMessage = [response.systemMessage, context].filter(Boolean).join('\n');
+    response.hookSpecificOutput = response.hookSpecificOutput || { hookEventName: 'PreToolUse' };
+    response.hookSpecificOutput.additionalContext = [response.hookSpecificOutput.additionalContext, context]
+      .filter(Boolean).join('\n');
+    return JSON.stringify(response);
+  } catch { return responseText; }
+}
+
+async function reconcileTaskScm(
+  root: string,
+  sessionId: string,
+  harness: string,
+  payload?: any,
+): Promise<TaskScmReconcileResult> {
+  if (!root || !sessionId) return { reason: '', context: '' };
+  try {
+    let branch = '';
+    let repoRoot = '';
+    let isWorktree = false;
+    try { branch = gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']); } catch {}
+    try { repoRoot = sharedRepoRoot(root); } catch {}
+    try { isWorktree = statSync(join(root, '.git')).isFile(); } catch {}
+    const nativeCodexWorktree = harness === 'codex' && codexDesktopOrigin();
+    const parentSessionId = codexForkedFromSession(payload, harness, sessionId);
+    const claimWorkspace = (reportedBranch: string) => fetch(
+      'http://127.0.0.1:' + PORT + '/api/local/task-scm/claim', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + loadMcpJwt() },
+        body: JSON.stringify({
+          sessionId, cwd: root, repoRoot, branch: reportedBranch, harness,
+          nativeCodexWorktree, isWorktree, parentSessionId,
+        }),
+        signal: AbortSignal.timeout(5000),
+      },
+    );
+    const claim = await claimWorkspace(branch);
+    if (!claim.ok) return { reason: '', context: '' };
+    let result = await claim.json() as any;
+    for (let attempt = 0; result?.retry === true && attempt < 50; attempt++) {
+      await new Promise((resolveRetry) => setTimeout(resolveRetry, 100));
+      try { branch = gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']); } catch {}
+      const retried = await claimWorkspace(branch);
+      if (!retried.ok) break;
+      result = await retried.json() as any;
+    }
+    if (!result?.op) {
+      const workspace = result?.workspace && typeof result.workspace === 'object'
+        ? { ...result.workspace }
+        : result?.workspace;
+      return {
+        reason: result?.waiting
+          ? (taskScmWorkspaceInstruction(harness, sessionId, workspace)
+            || String(result.reason || 'task source-control preparation is pending'))
+          : '',
+        context: taskScmWorkspaceContext(workspace, harness),
+      };
+    }
+    try {
+      const worktreePath = executeTaskScm(root, result.op, harness);
+      await completeTaskScm(sessionId, result.op, true, '', worktreePath);
+      if (result.op.kind === 'branch') {
+        if (result.op.adoptExistingWorktree === true) {
+          const rebound = await claimWorkspace(String(result.op.branchName || ''));
+          if (rebound.ok) {
+            const reboundResult = await rebound.json() as any;
+            if (!reboundResult?.waiting && reboundResult?.workspace) {
+              return { reason: '', context: taskScmWorkspaceContext(reboundResult.workspace, harness) };
+            }
+            if (reboundResult?.waiting) {
+              return {
+                reason: String(reboundResult.reason || 'Codex native worktree binding is pending'),
+                context: taskScmWorkspaceContext(reboundResult.workspace, harness),
+              };
+            }
+          }
+          return { reason: 'Codex native worktree branch was created but task binding is still pending', context: '' };
+        }
+        const workspace = {
+          taskId: result.op.taskId,
+          linearRef: result.op.linearRef,
+          branchName: result.op.branchName,
+          worktreePath,
+          bindingState: 'handoff_pending',
+        };
+        return {
+          reason: taskScmWorkspaceInstruction(harness, sessionId, workspace),
+          context: '',
+        };
+      }
+      return { reason: '', context: '' };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await completeTaskScm(sessionId, result.op, false, message, root);
+      return { reason: message, context: '' };
+    }
+  } catch { return { reason: '', context: '' }; }
+}
+
 // Once-per-session onboarding hint for repos with no synkro.toml file.
 function noSynkroHint(sessionId: string): string | null {
   const dir = join(HOME, '.synkro', '.no-synkro-hint');
@@ -3022,13 +3801,11 @@ function filePathFromToolInput(ti: any): string {
 // The container reconstructs the proposed post-edit content by finding the edit's old_string
 // inside baseContent, then computes the changed line-range + per-requirement file snapshot off
 // it. The old flat 64KB HEAD silently truncated any edit past ~the first 1000 lines of a big
-// file (e.g. an 890KB server file): old_string wasn't present, reconstruct produced garbage, and
-// that requirement could never be verified — it graded 'unknown' forever. Ship the WHOLE file
-// (covers virtually all source, incl. large single-file servers) so reconstruct + region math
-// are exact. Only a pathological >2MB file falls back to a line-aligned WINDOW around the edit
-// (front-padded with newlines so ABSOLUTE line numbers — which the container's region slicing
-// keys off — are preserved) instead of the head. This also fixes CWE/CVE scans that previously
-// never saw anything below 64KB in a large file.
+// file (e.g. an 890KB server file): old_string wasn't present, so reconstruction and the durable
+// edit fact were incomplete. Ship the WHOLE file (covers virtually all source, incl. large
+// single-file servers) so reconstruction, audit diffs, and policy/security scans are exact. Only
+// a pathological >2MB file falls back to a line-aligned WINDOW around the edit (front-padded with
+// newlines so ABSOLUTE line numbers are preserved) instead of the head.
 const BASE_CONTENT_WHOLE_CAP = 2000000;
 function editAnchorString(ti: any): string {
   if (!ti || typeof ti !== 'object') return '';
@@ -3436,11 +4213,19 @@ function readJsonlHeader(path: string): string {
   let fd = -1;
   try {
     fd = openSync(path, 'r');
-    const buf = Buffer.alloc(16384);
-    const count = readSync(fd, buf, 0, buf.length, 0);
-    const head = buf.subarray(0, count).toString('utf-8');
-    const newline = head.indexOf('\n');
-    return newline >= 0 ? head.slice(0, newline) : head;
+    const chunks: Buffer[] = [];
+    let position = 0;
+    while (position < 2 * 1024 * 1024) {
+      const buf = Buffer.alloc(Math.min(65536, 2 * 1024 * 1024 - position));
+      const count = readSync(fd, buf, 0, buf.length, position);
+      if (count <= 0) break;
+      const chunk = buf.subarray(0, count);
+      const newline = chunk.indexOf(10);
+      chunks.push(newline >= 0 ? chunk.subarray(0, newline) : chunk);
+      position += count;
+      if (newline >= 0) break;
+    }
+    return Buffer.concat(chunks).toString('utf-8');
   } catch { return ''; }
   finally { if (fd >= 0) { try { closeSync(fd); } catch {} } }
 }
@@ -3518,6 +4303,37 @@ export function resolveHookTranscriptPath(payload: any, harness: string, session
   return found;
 }
 
+function codexForkedFromSession(payload: any, harness: string, sessionId: string): string {
+  if (harness !== 'codex' || !safeCodexSessionId(sessionId)) return '';
+  const cachePath = join(
+    HOME,
+    '.synkro',
+    'codex-parent-' + createHash('sha256').update(sessionId).digest('hex').slice(0, 16),
+  );
+  try {
+    const cached = readFileSync(cachePath, 'utf-8').trim();
+    if (cached === '-') return '';
+    if (safeCodexSessionId(cached)) return cached;
+  } catch {}
+
+  let parent = '';
+  const transcriptPath = resolveHookTranscriptPath(payload, harness, sessionId);
+  if (transcriptPath) {
+    try {
+      const first = JSON.parse(readJsonlHeader(transcriptPath));
+      const candidate = String(first?.payload?.forked_from_id || first?.payload?.forkedFromId || '');
+      if (first?.type === 'session_meta' && safeCodexSessionId(candidate) && candidate !== sessionId) {
+        parent = candidate;
+      }
+    } catch {}
+  }
+  try {
+    mkdirSync(join(HOME, '.synkro'), { recursive: true });
+    writeFileSync(cachePath, parent || '-', { encoding: 'utf-8', mode: 0o600 });
+  } catch {}
+  return parent;
+}
+
 export async function runStub(surface: string, opts: StubOpts = {}): Promise<void> {
   const harness = isCursor(opts.harness) ? 'cursor' : isCodex(opts.harness) ? 'codex' : 'cc';
   const startedAt = Date.now();
@@ -3564,14 +4380,24 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
     const cwd = (typeof payload.cwd === 'string' && payload.cwd) || workspaceRoots[0] || '';
     const sessionId = String(payload.session_id || payload.conversation_id || '');
     const root = gitRoot(cwd);
+    telemCwd = root || cwd;
 
     // Dormancy: a repo is onboarded only if it has a synkro.toml FILE at its git
     // root. Guard root !== HOME — ~/.synkro is the config DIRECTORY, so without
     // this a home-rooted cwd (dotfiles in git, non-git dir under home) could
-    // look onboarded.
+    // look onboarded. A linked worktree checked out at a commit predating the
+    // tracked synkro.toml has no copy of its own — fall back to the main
+    // checkout's config rather than silently skipping enforcement there.
     let synkroFileText = '';
-    if (root && root !== HOME && existsSync(join(root, 'synkro.toml'))) {
-      try { synkroFileText = readFileSync(join(root, 'synkro.toml'), 'utf-8'); } catch {}
+    if (root && root !== HOME) {
+      let configRoot = root;
+      if (!existsSync(join(configRoot, 'synkro.toml'))) {
+        const mainRoot = mainWorktreeRoot(root);
+        if (mainRoot !== root && mainRoot !== HOME && existsSync(join(mainRoot, 'synkro.toml'))) {
+          configRoot = mainRoot;
+        }
+      }
+      try { synkroFileText = readFileSync(join(configRoot, 'synkro.toml'), 'utf-8'); } catch {}
     }
     if (!synkroFileText) {
       // Repo not onboarded — emit a minimal tool_call so usage analytics still
@@ -3598,6 +4424,31 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
       return;
     }
 
+    const scm = await reconcileTaskScm(root || cwd, sessionId, harness, payload);
+    const substantiveTool = /^(?:Bash|Edit|Write|MultiEdit|NotebookEdit|apply_patch|file_change)$/i.test(String(payload.tool_name || ''));
+    const scmTaskId = taskIdFromScmContext(scm.context);
+    // The user can settle the workspace question in plain language: while the
+    // ask is pending for this session's task, a stay-directive on the user's
+    // 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)) {
+      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 */ }
+      }
+    }
+    // The user was asked and chose to keep working here, or is answering right now.
+    const workspaceConsentSettled = Boolean(scmTaskId)
+      && (taskWorkspaceStayRecorded(scmTaskId) || isWorkspaceConsentCommand(payload, scmTaskId));
+    if (scm.reason && substantiveTool && !workspaceConsentSettled) {
+      out(taskScmBlockResponse(harness, scm.reason, firstHookForToolCall(sessionId, payload)));
+      return;
+    }
+
     if (harness === 'codex' && opts.needsFile && payload.__synkro_codex_patch_error) {
       const reason = String(payload.__synkro_codex_patch_error);
       out(JSON.stringify({
@@ -3613,7 +4464,17 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
     }
 
     // Gather host-only inputs the container can't read.
-    const envelope: any = { payload, harness, cwd: root || cwd, sessionId, synkroFileText };
+    const envelope: any = {
+      payload,
+      harness,
+      cwd: root || cwd,
+      sessionId,
+      synkroFileText,
+      taskWorkspaceContext: scm.context || undefined,
+    };
+    // Task creation is the one moment the container needs a stable Git snapshot.
+    // Capture it on the MCP gate only; ordinary tool hooks avoid extra Git calls.
+    if (surface === 'mcp-gate') envelope.repoContext = taskRepoContext(root || cwd);
 
     if (opts.needsFile) {
       const normalizedEdits = harness === 'codex' && Array.isArray(payload.__synkro_codex_edits)
@@ -3694,15 +4555,10 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
       envelope.planText = String(ti.plan || ti.content || payload.plan || '');
     }
 
-    // bash-followup is telemetry, but it can carry the INLINE "task complete ✓ N/N"
-    // result (the server waits up to 30s for the completion grade), so it needs a
-    // wait above that budget — not the 6s telemetry default — or the stub abandons
-    // the request before the result lands and the completion shows up a hook late.
-    // prompt-submit is the opposite: it's INTERACTIVE (blocks the user's prompt from
+    // prompt-submit is INTERACTIVE (blocks the user's prompt from
     // being sent) under a short 5s hook timeout, so it gets ONE short attempt (below)
     // and a tight per-attempt budget that fits inside 5s — never the 6s×3 telemetry path.
     const timeoutMs = surface === 'cwe-precheck' ? 48000
-      : surface === 'bash-followup' ? 32000
       : surface === 'prompt-submit' ? 3500
       : (opts.telemetry ? 6000 : 28000);
     // Cloud has no local container to reach. Post the SAME envelope to the org's grader
@@ -3727,8 +4583,8 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
     // latency: retry a few times with backoff. Right after a server restart the
     // event loop can be briefly busy / not-yet-listening and a single POST silently
     // drops the event (this was the followup flakiness). Double-delivery is safe here
-    // — the server side is idempotent-ish (completion in-flight guard, dup evidence
-    // is harmless). Blocking hooks make ONE attempt: their response IS the verdict
+    // because the server deduplicates durable hook events and native evidence.
+    // Blocking hooks make ONE attempt: their response IS the verdict
     // and a retry would double-grade. Normal case: first attempt wins, no delay.
     // prompt-submit is EXCLUDED from the retry: it runs on the interactive prompt
     // path under a 5s hook timeout, and 3×6s+backoff (19.5s) blew that budget and
@@ -3744,9 +4600,21 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
       if (i < attempts - 1) await new Promise((r) => setTimeout(r, 500 * (i + 1)));
     }
     const rawResponseText = text || failOpen(harness);
-    const responseText = opts.stopContract && harness === 'codex'
+    // A completion-report sync can arm the push after the pre-scan reconciliation ran.
+    // Reconcile once more so the same Stop/PostToolUse hook can push immediately.
+    await reconcileTaskScm(root || cwd, sessionId, harness, payload);
+    const contractResponseText = opts.stopContract && harness === 'codex'
       ? codexStopResponse(rawResponseText)
       : rawResponseText;
+    // Only the first hook of this tool call carries the workspace context; the other
+    // surfaces of the same call would otherwise repeat it verbatim 2-4 times.
+    let scmContext = scm.context && 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)) {
+      scmContext += ' workspace=staying-here-by-user-choice';
+    }
+    const responseText = withTaskScmContext(contractResponseText, harness, scmContext);
     out(responseText);
     emitStubTelemetry(surface, harness, telemPayload, responseText, Date.now() - startedAt, telemCwd, telemSessionId);
   } catch (err) {
@@ -4129,7 +4997,7 @@ function createCallbackServer() {
     "Access-Control-Allow-Headers": "Content-Type",
     "Vary": "Origin"
   };
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const server = createServer((req, res) => {
       if (req.method === "OPTIONS") {
         const origin = req.headers.origin;
@@ -4218,7 +5086,7 @@ function createCallbackServer() {
         res.end(JSON.stringify({ ok: true }));
         setTimeout(() => {
           server.close();
-          resolve6(authData);
+          resolve7(authData);
         }, 200);
       });
       req.on("error", (e) => {
@@ -4549,7 +5417,7 @@ function detectSubdirRepos() {
   }
 }
 function ask(rl, question) {
-  return new Promise((resolve6) => rl.question(question, resolve6));
+  return new Promise((resolve7) => rl.question(question, resolve7));
 }
 async function linkRepo(repo, linkedNames) {
   try {
@@ -4788,7 +5656,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((resolve6) => {
+  await new Promise((resolve7) => {
     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" : "" }
@@ -4804,7 +5672,7 @@ async function runClaudeDesktopTap(opts = {}) {
     child.on("exit", () => {
       process.off("SIGINT", forward);
       process.off("SIGTERM", forward);
-      resolve6();
+      resolve7();
     });
   });
 }
@@ -6610,10 +7478,8 @@ async function dockerInstall(opts = {}) {
     // Pass through the batch-size lever if the operator set it. Defaults
     // inside the container to 5; clamped to [1, 20] by synkro-server.ts.
     ...process.env.SYNKRO_MAX_BATCH_SIZE ? ["-e", `SYNKRO_MAX_BATCH_SIZE=${process.env.SYNKRO_MAX_BATCH_SIZE}`] : [],
-    // Full verifier prompt/response tracing is explicit opt-in because it contains source code.
-    ...process.env.SYNKRO_VERIFY_TRACE === "1" ? ["-e", "SYNKRO_VERIFY_TRACE=1"] : [],
     // Explicit model overrides are preserved across local install/update for
-    // every provider and isolated lane. The server reports the resolved values
+    // every provider and the isolated route lane. The server reports the resolved values
     // in /healthz so operators can audit exactly what is spending tokens.
     ...[
       "SYNKRO_CLAUDE_MODEL",
@@ -6647,8 +7513,8 @@ async function dockerInstall(opts = {}) {
     "SYNKRO_TELEMETRY_QUEUE=/data/synkro-host/telemetry-pending.jsonl",
     image
   ];
-  const run = spawnSync3("docker", args2, { encoding: "utf-8", stdio: "inherit", timeout: 6e4 });
-  if (run.status !== 0) {
+  const run2 = spawnSync3("docker", args2, { encoding: "utf-8", stdio: "inherit", timeout: 6e4 });
+  if (run2.status !== 0) {
     throw new DockerInstallError(`docker run failed (image ${image})`);
   }
   return {
@@ -6879,7 +7745,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.7.95";
+      if (true) return "1.9.0";
       try {
         const pkg = JSON.parse(readFileSync17(new URL("../../package.json", import.meta.url), "utf8"));
         if (pkg.version) return pkg.version;
@@ -6911,7 +7777,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((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = nodeSpawn(bin, args2, {
       stdio: "inherit",
       env: { ...process.env, FORCE_COLOR: "3", COLORTERM: "truecolor", TERM: "xterm-256color" }
@@ -6978,7 +7844,7 @@ function captureClaudeSetupToken() {
         reject(new Error(`Captured no setup token from claude setup-token output. ${reason}`));
         return;
       }
-      resolve6(token);
+      resolve7(token);
     });
   });
 }
@@ -7004,13 +7870,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((resolve6, reject) => {
+  return new Promise((resolve7, 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 ? resolve6() : reject(new Error(`codex login exited with code ${code}`)));
+    proc.on("close", (code) => code === 0 ? resolve7() : reject(new Error(`codex login exited with code ${code}`)));
   });
 }
 async function setupCodexCloud(gatewayUrl, bearerToken, onStatus) {
@@ -7587,7 +8453,7 @@ function isoDay(value, fallbackDay) {
 function parseClaudeTranscriptUsage(transcript, fallbackDay = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), options = {}) {
   const seen = options.seenStableIds ?? /* @__PURE__ */ new Set();
   const rollups = /* @__PURE__ */ new Map();
-  const usage = {
+  const usage2 = {
     input_tokens: 0,
     output_tokens: 0,
     cache_creation_input_tokens: 0,
@@ -7621,7 +8487,7 @@ function parseClaudeTranscriptUsage(transcript, fallbackDay = (/* @__PURE__ */ n
       if (entryModel !== "<synthetic>") model = entryModel;
       const day = isoDay(entry.timestamp, fallbackDay);
       const key = `${day}\0${entryModel}`;
-      const row = rollups.get(key) ?? {
+      const row2 = rollups.get(key) ?? {
         day,
         model: entryModel,
         turns: 0,
@@ -7630,23 +8496,23 @@ function parseClaudeTranscriptUsage(transcript, fallbackDay = (/* @__PURE__ */ n
         cache_creation_input_tokens: 0,
         cache_read_input_tokens: 0
       };
-      row.turns += 1;
-      row.input_tokens += counts.input_tokens;
-      row.output_tokens += counts.output_tokens;
-      row.cache_creation_input_tokens += counts.cache_creation_input_tokens;
-      row.cache_read_input_tokens += counts.cache_read_input_tokens;
-      rollups.set(key, row);
+      row2.turns += 1;
+      row2.input_tokens += counts.input_tokens;
+      row2.output_tokens += counts.output_tokens;
+      row2.cache_creation_input_tokens += counts.cache_creation_input_tokens;
+      row2.cache_read_input_tokens += counts.cache_read_input_tokens;
+      rollups.set(key, row2);
       turns += 1;
-      usage.input_tokens += counts.input_tokens;
-      usage.output_tokens += counts.output_tokens;
-      usage.cache_creation_input_tokens += counts.cache_creation_input_tokens;
-      usage.cache_read_input_tokens += counts.cache_read_input_tokens;
+      usage2.input_tokens += counts.input_tokens;
+      usage2.output_tokens += counts.output_tokens;
+      usage2.cache_creation_input_tokens += counts.cache_creation_input_tokens;
+      usage2.cache_read_input_tokens += counts.cache_read_input_tokens;
     } catch {
     }
   }
   if (turns === 0) return null;
   return {
-    usage,
+    usage: usage2,
     model: model || "unknown",
     rollups: [...rollups.values()].sort(
       (a, b) => a.day.localeCompare(b.day) || a.model.localeCompare(b.model)
@@ -7712,20 +8578,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((resolve6) => {
+  const ask3 = () => new Promise((resolve7) => {
     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 resolve6(detected);
+        return resolve7(detected);
       }
       const n = parseInt(t, 10);
       if (Number.isInteger(n) && n >= 1 && n <= detected.length) {
         rl.close();
-        return resolve6([detected[n - 1]]);
+        return resolve7([detected[n - 1]]);
       }
       console.log("Invalid choice. Try again.");
-      resolve6(ask3());
+      resolve7(ask3());
     });
   });
   return ask3();
@@ -7748,12 +8614,12 @@ async function promptCursorApiKey(opts) {
     return;
   }
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  const key = await new Promise((resolve6) => {
+  const key = await new Promise((resolve7) => {
     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();
-        resolve6(answer.trim());
+        resolve7(answer.trim());
       }
     );
   });
@@ -7768,7 +8634,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((resolve6) => {
+  return new Promise((resolve7) => {
     rl.question(
       `Where should Synkro run?
   local \u2014 a grading container on this machine (Docker)
@@ -7777,7 +8643,7 @@ Each worker uses the account credentials you authorize. Choose [${current}] / ${
       (answer) => {
         rl.close();
         const a = answer.trim().toLowerCase();
-        resolve6(a === "cloud" ? "cloud" : a === "local" ? "local" : current);
+        resolve7(a === "cloud" ? "cloud" : a === "local" ? "local" : current);
       }
     );
   });
@@ -7936,7 +8802,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle2(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle2(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle2(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle2("1.7.95")}`
+    `SYNKRO_VERSION=${shellQuoteSingle2("1.9.0")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle2(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle2(safeUserId)}`);
@@ -8683,7 +9549,7 @@ async function installCommand(opts = {}) {
   await setTelemetryState({ enabled: true, remoteFlushEnabled: telemetryConsent });
   emit("install", {
     phase: "started",
-    cli_version_to: "1.7.95",
+    cli_version_to: "1.9.0",
     agents_detected: agents.map((a) => a.kind),
     with_github: false,
     with_local_cc: false,
@@ -9544,7 +10410,7 @@ async function syncSkillFiles() {
 function normSkillName(name) {
   return name.toLowerCase().replace(/\.mdx?$/, "");
 }
-function discoverSkillFiles(repoRoot2, excludeHashes, ingestedHashes, ingestedNames) {
+function discoverSkillFiles(repoRoot3, excludeHashes, ingestedHashes, ingestedNames) {
   const roots = [];
   const add = (p) => {
     try {
@@ -9554,9 +10420,9 @@ function discoverSkillFiles(repoRoot2, excludeHashes, ingestedHashes, ingestedNa
   };
   add(join19(homedir21(), ".claude", "skills"));
   add(join19(homedir21(), ".agents", "skills"));
-  if (repoRoot2) {
-    add(join19(repoRoot2, ".claude", "skills"));
-    add(join19(repoRoot2, ".agents", "skills"));
+  if (repoRoot3) {
+    add(join19(repoRoot3, ".claude", "skills"));
+    add(join19(repoRoot3, ".agents", "skills"));
   }
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -9639,7 +10505,7 @@ Found ${found.length} skill${found.length === 1 ? "" : "s"} in your Claude Code
 async function discoverAndIngestSkills() {
   try {
     const sf = readFullSynkroFile();
-    const repoRoot2 = sf?._repoRoot || detectGitRepo2();
+    const repoRoot3 = sf?._repoRoot || detectGitRepo2();
     const mcpPort = process.env.SYNKRO_MCP_PORT || "18931";
     const excludeHashes = /* @__PURE__ */ new Set();
     if (sf?.skills?.length) {
@@ -9663,7 +10529,7 @@ async function discoverAndIngestSkills() {
       }
     } catch {
     }
-    const found = discoverSkillFiles(repoRoot2, excludeHashes, ingestedHashes, ingestedNames);
+    const found = discoverSkillFiles(repoRoot3, excludeHashes, ingestedHashes, ingestedNames);
     if (found.length === 0) return;
     const selectable = found.filter((f) => !f.ingested);
     if (selectable.length === 0) {
@@ -9699,18 +10565,18 @@ async function discoverAndIngestSkills() {
   }
 }
 function resolveSynkroBinPath() {
-  const run = (cmd3) => {
+  const run2 = (cmd3) => {
     try {
       return execSync4(cmd3, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
     } catch {
       return "";
     }
   };
-  const p = run("command -v synkro").split("\n")[0].trim();
+  const p = run2("command -v synkro").split("\n")[0].trim();
   return p && isAbsolute(p) ? p : "";
 }
 function ensureReachabilityGitHook() {
-  const run = (cmd3) => {
+  const run2 = (cmd3) => {
     try {
       return execSync4(cmd3, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
     } catch {
@@ -9718,9 +10584,9 @@ function ensureReachabilityGitHook() {
     }
   };
   try {
-    const root = run("git rev-parse --show-toplevel");
+    const root = run2("git rev-parse --show-toplevel");
     if (!root) return null;
-    let hooksDir = run("git config --get core.hooksPath");
+    let hooksDir = run2("git config --get core.hooksPath");
     hooksDir = hooksDir ? isAbsolute(hooksDir) ? hooksDir : join19(root, hooksDir) : join19(root, ".git", "hooks");
     if (!existsSync22(hooksDir)) mkdirSync15(hooksDir, { recursive: true });
     const hookPath = join19(hooksDir, "post-commit");
@@ -9762,18 +10628,18 @@ function ensureReachabilityGitHook() {
   }
 }
 function detectGitRepo2() {
-  const run = (cmd3) => {
+  const run2 = (cmd3) => {
     try {
       return execSync4(cmd3, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
     } catch {
       return "";
     }
   };
-  const remoteUrl = run("git remote get-url origin");
+  const remoteUrl = run2("git remote get-url origin");
   if (remoteUrl) {
     return remoteUrl.replace(/^git@[^:]+:/, "").replace(/^https?:\/\/[^/]+\//, "").replace(/\.git$/, "");
   }
-  const root = run("git rev-parse --show-toplevel");
+  const root = run2("git rev-parse --show-toplevel");
   return root ? root.split("/").pop() || null : null;
 }
 function getClaudeProjectsFolder() {
@@ -9890,13 +10756,13 @@ function extractTextContent(content) {
 function getCodexTranscriptFiles(repo) {
   const sessionsDir = join19(process.env.CODEX_HOME || join19(homedir21(), ".codex"), "sessions");
   if (!existsSync22(sessionsDir)) return [];
-  let relative = [];
+  let relative2 = [];
   try {
-    relative = readdirSync4(sessionsDir, { recursive: true, encoding: "utf-8" });
+    relative2 = readdirSync4(sessionsDir, { recursive: true, encoding: "utf-8" });
   } catch {
     return [];
   }
-  return relative.filter((p) => p.endsWith(".jsonl")).map((p) => join19(sessionsDir, p)).filter((filePath) => {
+  return relative2.filter((p) => p.endsWith(".jsonl")).map((p) => join19(sessionsDir, p)).filter((filePath) => {
     try {
       const first = readFileSync21(filePath, "utf-8").split("\n", 1)[0];
       const meta = JSON.parse(first);
@@ -10971,10 +11837,10 @@ function confirmPurge() {
     return Promise.resolve(false);
   }
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     rl.question("   Type 'yes' to wipe everything (anything else cancels): ", (answer) => {
       rl.close();
-      resolve6(answer.trim().toLowerCase() === "yes");
+      resolve7(answer.trim().toLowerCase() === "yes");
     });
   });
 }
@@ -11227,7 +12093,7 @@ async function submitToChannel(role, payload, opts = {}) {
   const port = opts.port ?? CHANNEL_PORT;
   const startedAt = Date.now();
   try {
-    const result = await new Promise((resolve6, reject) => {
+    const result = await new Promise((resolve7, reject) => {
       const req = httpRequest({
         host: CHANNEL_HOST,
         port,
@@ -11253,7 +12119,7 @@ async function submitToChannel(role, payload, opts = {}) {
               reject(new LocalCCError(parsed.error));
               return;
             }
-            resolve6(String(parsed.result ?? ""));
+            resolve7(String(parsed.result ?? ""));
           } catch (err) {
             reject(new LocalCCError(`malformed channel response: ${text.slice(0, 200)}`, err));
           }
@@ -11279,14 +12145,14 @@ async function submitToChannel(role, payload, opts = {}) {
   }
 }
 function isChannelAvailable(port = CHANNEL_PORT, timeoutMs = 500) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const sock = connect(port, CHANNEL_HOST);
     const done = (ok) => {
       try {
         sock.destroy();
       } catch {
       }
-      resolve6(ok);
+      resolve7(ok);
     };
     sock.once("connect", () => done(true));
     sock.once("error", () => done(false));
@@ -11318,10 +12184,10 @@ __export(grade_exports, {
   gradeCommand: () => gradeCommand
 });
 async function readStdin() {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const chunks = [];
     process.stdin.on("data", (c) => chunks.push(c));
-    process.stdin.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("end", () => resolve7(Buffer.concat(chunks).toString("utf-8")));
     process.stdin.on("error", reject);
   });
 }
@@ -11575,7 +12441,7 @@ function spawnClaudeJudge(file, claudeToken, promptHeader) {
 Diff:
 ${hunks}`;
   const fullPrompt = promptHeader + userMessage;
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const t0 = Date.now();
     const proc = spawn6(
       "claude",
@@ -11603,7 +12469,7 @@ ${hunks}`;
       const latencyMs = Date.now() - t0;
       if (code !== 0) {
         console.warn(`  claude exited ${code}: ${(stderr || stdout).slice(0, 500)}`);
-        resolve6({ findings: [], latencyMs });
+        resolve7({ findings: [], latencyMs });
         return;
       }
       try {
@@ -11622,10 +12488,10 @@ ${hunks}`;
           description: f.description,
           fix: f.fix
         }));
-        resolve6({ findings, latencyMs });
+        resolve7({ findings, latencyMs });
       } catch (parseErr) {
         console.warn(`  failed to parse claude response: ${stdout.slice(0, 300)}`);
-        resolve6({ findings: [], latencyMs });
+        resolve7({ findings: [], latencyMs });
       }
     });
   });
@@ -11674,7 +12540,7 @@ ${JSON.stringify(findings, null, 2)}
 `;
 }
 function spawnOpusConsolidator(findings, claudeToken) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const prompt = buildConsolidationPrompt(findings);
     const proc = spawn6(
       "claude",
@@ -11701,7 +12567,7 @@ function spawnOpusConsolidator(findings, claudeToken) {
     proc.on("close", (code) => {
       if (code !== 0) {
         console.warn(`  opus consolidation exited ${code}: ${(stderr || stdout).slice(0, 300)}`);
-        resolve6(fallbackReview(findings));
+        resolve7(fallbackReview(findings));
         return;
       }
       try {
@@ -11722,10 +12588,10 @@ function spawnOpusConsolidator(findings, claudeToken) {
           const order = ["low", "medium", "high", "critical"];
           return order.indexOf(f.severity) > order.indexOf(max) ? f.severity : max;
         }, "low");
-        resolve6({ summary: review.summary || "", comments, severity: maxSeverity });
+        resolve7({ summary: review.summary || "", comments, severity: maxSeverity });
       } catch {
         console.warn(`  failed to parse opus response, using fallback`);
-        resolve6(fallbackReview(findings));
+        resolve7(fallbackReview(findings));
       }
     });
   });
@@ -12208,14 +13074,14 @@ function ensureRunning(opts = {}) {
   return startTask(opts);
 }
 function probePort(host, port, timeoutMs = 500) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const sock = connect2(port, host);
     const done = (ok) => {
       try {
         sock.destroy();
       } catch {
       }
-      resolve6(ok);
+      resolve7(ok);
     };
     sock.once("connect", () => done(true));
     sock.once("error", () => done(false));
@@ -12765,7 +13631,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((resolve6) => {
+  return new Promise((resolve7) => {
     console.log("  " + colorize("\u2014 following new turns (Ctrl-C to exit) \u2014", 90));
     const stop = followTurns((t) => {
       console.log("  " + formatTurn(t, raw));
@@ -12773,7 +13639,7 @@ function cmdLogs(rest) {
     const onSigint = () => {
       stop();
       process.removeListener("SIGINT", onSigint);
-      resolve6();
+      resolve7();
     };
     process.on("SIGINT", onSigint);
   });
@@ -13062,9 +13928,9 @@ function parseSession(file, seenStableIds) {
 }
 function ask2(q) {
   const rl = createInterface4({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve6) => rl.question(q, (a) => {
+  return new Promise((resolve7) => rl.question(q, (a) => {
     rl.close();
-    resolve6(/^y(es)?$/i.test(a.trim()));
+    resolve7(/^y(es)?$/i.test(a.trim()));
   }));
 }
 async function importCommand() {
@@ -13197,8 +14063,8 @@ function canonicalize(pack) {
     docs: pack.docs ?? []
   });
 }
-function computeDigest(canonical) {
-  return "sha256:" + crypto.createHash("sha256").update(canonical, "utf8").digest("hex");
+function computeDigest(canonical2) {
+  return "sha256:" + crypto.createHash("sha256").update(canonical2, "utf8").digest("hex");
 }
 function verifySignature(digest, signatureB64, publicKeyPem) {
   try {
@@ -13222,10 +14088,10 @@ var init_packVerify = __esm({
 // cli/installer/lockfile.ts
 import { existsSync as existsSync30, readFileSync as readFileSync28, writeFileSync as writeFileSync20 } from "fs";
 import { join as join28 } from "path";
-function lockPath(repoRoot2) {
-  return join28(repoRoot2, LOCK_FILE);
+function lockPath(repoRoot3) {
+  return join28(repoRoot3, LOCK_FILE);
 }
-function writeLockfile(repoRoot2, entries) {
+function writeLockfile(repoRoot3, entries) {
   const sorted = [...entries].sort((a, b) => a.ref.localeCompare(b.ref));
   const body = [
     "# synkro.lock \u2014 generated by `synkro sync`. Commit this file.",
@@ -13241,7 +14107,7 @@ function writeLockfile(repoRoot2, entries) {
       ""
     ])
   ].join("\n");
-  writeFileSync20(lockPath(repoRoot2), body, "utf-8");
+  writeFileSync20(lockPath(repoRoot3), body, "utf-8");
 }
 var LOCK_FILE;
 var init_lockfile = __esm({
@@ -13453,51 +14319,867 @@ var init_whoami = __esm({
   }
 });
 
-// cli/commands/refresh.ts
-var refresh_exports = {};
-__export(refresh_exports, {
-  refreshCommand: () => refreshCommand
+// cli/commands/workspace.ts
+var workspace_exports = {};
+__export(workspace_exports, {
+  workspaceCommand: () => workspaceCommand
 });
-async function refreshCommand(args2 = []) {
-  const json = args2.includes("--json");
-  const creds = loadCredentials();
-  if (!creds?.refresh_token) {
-    if (json) console.log(JSON.stringify({ refreshed: false, reason: "no refresh_token" }));
-    else console.error("Not logged in (no refresh_token) \u2014 run `synkro login`.");
-    process.exit(1);
+import { existsSync as existsSync33, mkdirSync as mkdirSync19, readdirSync as readdirSync8, rmSync as rmSync5, writeFileSync as writeFileSync22 } from "fs";
+import { join as join31 } from "path";
+import { homedir as homedir31 } from "os";
+function markerPath(taskId) {
+  return join31(WORKSPACE_CHOICE_DIR, `${taskId}.stay`);
+}
+function usage() {
+  console.log(`synkro workspace \u2014 record where a task's work happens
+
+Usage:
+  synkro workspace stay <taskId>     keep working in the current checkout
+  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.`);
+}
+async function workspaceCommand(args2) {
+  const sub = String(args2[0] || "").trim();
+  const taskId = String(args2[1] || "").trim();
+  if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+    usage();
+    return;
   }
-  const ok = await refreshToken();
-  if (json) {
-    console.log(JSON.stringify({ refreshed: ok }));
-  } else if (ok) {
-    console.log("\u2713 Synkro session refreshed.");
-  } else {
-    console.error("Could not refresh \u2014 the refresh_token may be revoked. Run `synkro login`.");
+  if (sub === "status") {
+    let recorded = [];
+    try {
+      recorded = existsSync33(WORKSPACE_CHOICE_DIR) ? readdirSync8(WORKSPACE_CHOICE_DIR).filter((name) => name.endsWith(".stay")) : [];
+    } catch {
+      recorded = [];
+    }
+    if (taskId) {
+      const on = recorded.includes(`${taskId}.stay`);
+      console.log(`${taskId}: ${on ? "stay recorded" : "no choice recorded"}`);
+      return;
+    }
+    if (recorded.length === 0) {
+      console.log("No workspace choices recorded.");
+      return;
+    }
+    console.log("Staying in the current checkout for:");
+    for (const name of recorded.sort()) console.log(`  ${name.replace(/\.stay$/, "")}`);
+    return;
   }
-  if (!ok) process.exit(1);
+  if (sub !== "stay" && sub !== "clear") {
+    console.error(`Unknown workspace subcommand: ${sub}`);
+    usage();
+    process.exitCode = 2;
+    return;
+  }
+  if (!TASK_ID.test(taskId)) {
+    console.error(taskId ? `Not a task id: ${taskId} (expected task_ followed by 8 characters)` : `Usage: synkro workspace ${sub} <taskId>`);
+    process.exitCode = 2;
+    return;
+  }
+  if (sub === "clear") {
+    try {
+      rmSync5(markerPath(taskId), { force: true });
+    } catch {
+    }
+    console.log(`Cleared the workspace choice for ${taskId}.`);
+    return;
+  }
+  try {
+    mkdirSync19(WORKSPACE_CHOICE_DIR, { recursive: true });
+    writeFileSync22(markerPath(taskId), `${(/* @__PURE__ */ new Date()).toISOString()}
+`, "utf-8");
+  } catch (error) {
+    console.error(`Could not record the workspace choice: ${error?.message || error}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`Staying in the current checkout for ${taskId}. Synkro will not ask again for this task.`);
 }
-var init_refresh = __esm({
-  "cli/commands/refresh.ts"() {
+var WORKSPACE_CHOICE_DIR, TASK_ID;
+var init_workspace = __esm({
+  "cli/commands/workspace.ts"() {
     "use strict";
-    init_stub();
+    WORKSPACE_CHOICE_DIR = join31(homedir31(), ".synkro", "workspace-choice");
+    TASK_ID = /^task_[a-z0-9]{8}$/i;
   }
 });
 
-// cli/commands/linear.ts
-var linear_exports = {};
-__export(linear_exports, {
-  formatLinks: () => formatLinks,
-  linearCommand: () => linearCommand
-});
-import { readFileSync as readFileSync30 } from "fs";
-import { homedir as homedir31 } from "os";
-import { join as join31 } from "path";
-function mcpJwt() {
-  try {
-    return readFileSync30(join31(SYNKRO_DIR14, ".mcp-jwt"), "utf-8").trim();
-  } catch {
-    return "";
-  }
+// cli/ui/tmux.ts
+import { execFile as execFile2, spawnSync as spawnSync11 } from "child_process";
+import { promisify } from "util";
+function runnerArgs(runner, argv) {
+  return runner.kind === "container" ? ["docker", "exec", "-u", CONTAINER_USER, runner.container, ...argv] : argv;
+}
+function runnerInteractiveArgs(runner, argv) {
+  return runner.kind === "container" ? ["docker", "exec", "-it", "-u", CONTAINER_USER, runner.container, ...argv] : argv;
+}
+async function run(runner, argv) {
+  const [cmd3, ...args2] = runnerArgs(runner, argv);
+  try {
+    const { stdout, stderr } = await execFileAsync(cmd3, args2, { timeout: 8e3, maxBuffer: 1024 * 1024 });
+    return { ok: true, stdout: String(stdout || ""), stderr: String(stderr || "") };
+  } catch (error) {
+    return { ok: false, stdout: String(error?.stdout || ""), stderr: String(error?.stderr || error?.message || "") };
+  }
+}
+function runInherit(argv) {
+  const [cmd3, ...args2] = argv;
+  const result = spawnSync11(cmd3, args2, { stdio: "inherit" });
+  return result.status ?? 1;
+}
+function slugify(name) {
+  return String(name || "").toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "agent";
+}
+function agentSession(name) {
+  return AGENT_PREFIX + slugify(name);
+}
+function buildSpawnAgent(opts) {
+  const session = agentSession(opts.name);
+  return [
+    ["tmux", "new-session", "-d", "-s", session, "-c", opts.cwd, opts.command],
+    ["tmux", "set-option", "-t", session, "status", "off"],
+    ["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],
+    // Keep the pane visible after exit so the sidebar can render 'done'
+    // instead of the agent silently vanishing.
+    ["tmux", "set-option", "-t", session, "remain-on-exit", "on"]
+  ];
+}
+function buildListAgents() {
+  return ["tmux", "list-sessions", "-F", ["#{session_name}", "#{?pane_dead,dead,alive}", "#{@synkro_harness}", "#{@synkro_space}", "#{@synkro_backend}", "#{@synkro_pueue}"].join(FIELD_SEP)];
+}
+function buildCapture(session, lines = 14) {
+  return ["tmux", "capture-pane", "-p", "-t", session, "-S", String(-lines)];
+}
+function buildKillSession(session) {
+  return ["tmux", "kill-session", "-t", session];
+}
+function buildSetOption(session, option, value) {
+  return ["tmux", "set-option", "-t", session, "-q", option, value];
+}
+function buildSendText(session, text) {
+  return [
+    ["tmux", "send-keys", "-t", session, "-l", text],
+    ["tmux", "send-keys", "-t", session, "Enter"]
+  ];
+}
+function buildInterrupt(session) {
+  return ["tmux", "send-keys", "-t", session, "Escape"];
+}
+function buildCenterAttachCommand(runner, session) {
+  const argv = runnerInteractiveArgs(runner, ["tmux", "attach-session", "-t", session]);
+  return "env TMUX= " + argv.map(shellQuote3).join(" ");
+}
+function shellQuote3(value) {
+  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : "'" + value.replace(/'/g, "'\\''") + "'";
+}
+function parseAgentSessions(output, backend) {
+  return String(output || "").split("\n").map((line) => line.split(FIELD_SEP)).filter((cols) => cols[0]?.startsWith(AGENT_PREFIX)).map((cols) => ({
+    session: cols[0],
+    name: cols[0].slice(AGENT_PREFIX.length),
+    dead: cols[1] === "dead",
+    harness: cols[2] || "claude",
+    space: cols[3] || "",
+    backend: cols[4] || backend,
+    pueue: cols[5] || ""
+  }));
+}
+function parseWorktrees(porcelain) {
+  const rows = [];
+  let current = {};
+  for (const line of String(porcelain || "").split("\n")) {
+    if (line.startsWith("worktree ")) current = { path: line.slice(9).trim() };
+    else if (line.startsWith("branch ")) current.branch = line.slice(7).replace("refs/heads/", "").trim();
+    else if (line.trim() === "" && current.path) {
+      rows.push({
+        path: current.path,
+        branch: current.branch || "detached",
+        name: current.path.split("/").filter(Boolean).pop() || current.path
+      });
+      current = {};
+    }
+  }
+  if (current.path) {
+    rows.push({
+      path: current.path,
+      branch: current.branch || "detached",
+      name: current.path.split("/").filter(Boolean).pop() || current.path
+    });
+  }
+  return rows;
+}
+var execFileAsync, AGENT_PREFIX, UI_SESSION, CONTAINER_USER, FIELD_SEP;
+var init_tmux = __esm({
+  "cli/ui/tmux.ts"() {
+    "use strict";
+    execFileAsync = promisify(execFile2);
+    AGENT_PREFIX = "synkro-agent-";
+    UI_SESSION = "synkro-ui";
+    CONTAINER_USER = "synkro";
+    FIELD_SEP = "|";
+  }
+});
+
+// cli/ui/launch.ts
+function welcomeCommand() {
+  const banner = [
+    "",
+    "   synkro ui",
+    "   governed agents, one screen",
+    "",
+    "   enter  attach selected agent",
+    "   n      new agent in selected space",
+    "   c      new container agent",
+    "   g/s/y  consent: track / skip / stay",
+    "   T      new tab      q  quit",
+    ""
+  ].join("\\n");
+  return "printf " + shellQuote3(banner + "\\n") + "; tail -f /dev/null";
+}
+function sidebarCommand(bootPath, centerPane, repoCwd) {
+  const env = [
+    "SYNKRO_UI_CENTER=" + shellQuote3(centerPane),
+    "SYNKRO_UI_OUTER=" + UI_SESSION,
+    "SYNKRO_UI_BOOT=" + shellQuote3(bootPath),
+    "SYNKRO_UI_REPO=" + shellQuote3(repoCwd)
+  ].join(" ");
+  return "env " + env + " node " + shellQuote3(bootPath) + " ui --sidebar";
+}
+async function styleOuterSession() {
+  const style = [
+    ["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-left", " synkro "],
+    ["set-option", "-t", UI_SESSION, "status-left-style", "fg=colour135,bold"],
+    ["set-option", "-t", UI_SESSION, "status-right", " + (T new tab) "],
+    ["set-option", "-t", UI_SESSION, "status-right-style", "fg=colour240"],
+    ["set-option", "-t", UI_SESSION, "-w", "window-status-format", "  #W  "],
+    ["set-option", "-t", UI_SESSION, "-w", "window-status-current-format", "#[bg=colour135,fg=colour233,bold]  #W  #[default]"],
+    ["set-option", "-t", UI_SESSION, "pane-border-style", "fg=colour236"],
+    ["set-option", "-t", UI_SESSION, "pane-active-border-style", "fg=colour135"],
+    // Tab keys without the prefix: Alt+t new tab, Alt+arrows to move.
+    ["bind-key", "-n", "M-t", "new-window"],
+    ["bind-key", "-n", "M-Right", "next-window"],
+    ["bind-key", "-n", "M-Left", "previous-window"]
+  ];
+  for (const argv of style) await run(HOST, ["tmux", ...argv]);
+}
+async function buildTab(bootPath, repoCwd, windowTarget) {
+  if (windowTarget === void 0) {
+    await run(HOST, ["tmux", "new-session", "-d", "-s", UI_SESSION, "-x", "220", "-y", "55", welcomeCommand()]);
+    windowTarget = UI_SESSION + ":0";
+  } else {
+    const created = await run(HOST, ["tmux", "new-window", "-t", UI_SESSION, "-P", "-F", "#{window_id}", welcomeCommand()]);
+    windowTarget = created.stdout.trim() || windowTarget;
+  }
+  await run(HOST, ["tmux", "rename-window", "-t", windowTarget, "space"]);
+  const split = await run(HOST, [
+    "tmux",
+    "split-window",
+    "-hb",
+    "-t",
+    windowTarget,
+    "-l",
+    SIDEBAR_WIDTH,
+    "-P",
+    "-F",
+    "#{pane_id}",
+    "tail -f /dev/null"
+  ]);
+  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, ["tmux", "respawn-pane", "-k", "-t", sidebarPane, sidebarCommand(bootPath, centerPane, repoCwd)]);
+}
+async function uiSessionExists() {
+  const result = await run(HOST, ["tmux", "has-session", "-t", UI_SESSION]);
+  return result.ok;
+}
+async function launchUi(bootPath, repoCwd) {
+  if (!await uiSessionExists()) {
+    await buildTab(bootPath, repoCwd);
+    await styleOuterSession();
+  }
+  return runInherit(process.env.TMUX ? ["tmux", "switch-client", "-t", UI_SESSION] : ["tmux", "attach-session", "-t", UI_SESSION]);
+}
+var SIDEBAR_WIDTH, HOST;
+var init_launch = __esm({
+  "cli/ui/launch.ts"() {
+    "use strict";
+    init_tmux();
+    SIDEBAR_WIDTH = "34";
+    HOST = { kind: "host" };
+  }
+});
+
+// cli/ui/model.ts
+function detectAsk(tail2) {
+  for (const marker of BLOCK_MARKERS) {
+    if (marker.pattern.test(String(tail2 || ""))) return marker.ask;
+  }
+  return null;
+}
+function deriveStatus(input) {
+  if (input.dead) return { status: "done" };
+  const ask3 = detectAsk(input.tail);
+  if (ask3) return { status: "blocked", ask: ask3 };
+  return { status: input.changed ? "working" : "idle" };
+}
+function hashTail(tail2) {
+  let hash = 0;
+  const text = String(tail2 || "");
+  for (let index = 0; index < text.length; index += 1) {
+    hash = (hash << 5) - hash + text.charCodeAt(index) | 0;
+  }
+  return String(hash);
+}
+function mapAgentToTask(spacePath, tasks) {
+  const normalized = String(spacePath || "").replace(/\/+$/, "");
+  if (!normalized) return void 0;
+  const hit = tasks.find((task) => task.worktree && task.worktree.replace(/\/+$/, "") === normalized);
+  return hit?.linear || void 0;
+}
+async function fetchConductorTasks(baseUrl) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 900);
+    const response = await fetch(baseUrl + "/api/local/conductor/repositories", { signal: controller.signal });
+    clearTimeout(timer);
+    if (!response.ok) return [];
+    const payload = await response.json().catch(() => null);
+    return Array.isArray(payload?.tasks) ? payload.tasks.map((task) => ({
+      worktree: task?.worktree || null,
+      linear: task?.linear?.key || null,
+      status: String(task?.status || "")
+    })) : [];
+  } catch {
+    return [];
+  }
+}
+async function discoverHostSpaces(repoCwd) {
+  const result = await run({ kind: "host" }, ["git", "-C", repoCwd, "worktree", "list", "--porcelain"]);
+  if (!result.ok) return [];
+  return parseWorktrees(result.stdout).map((row2) => ({
+    name: row2.name,
+    branch: row2.branch,
+    path: row2.path,
+    backend: "host"
+  }));
+}
+async function discoverContainerSpaces(runner) {
+  if (runner.kind !== "container") return [];
+  const result = await run(runner, ["sh", "-c", "ls -1 /home/synkro/work 2>/dev/null"]);
+  if (!result.ok) return [];
+  return result.stdout.split("\n").map((line) => line.trim()).filter((name) => /^ui-/.test(name)).map((name) => ({
+    name,
+    branch: "container",
+    path: "/home/synkro/work/" + name,
+    backend: "container"
+  }));
+}
+async function discoverAgents(runner, backend, previousHashes) {
+  const listed = await run(runner, buildListAgents());
+  const rows = listed.ok ? parseAgentSessions(listed.stdout, backend) : [];
+  const hashes = /* @__PURE__ */ new Map();
+  const agents = [];
+  for (const row2 of rows) {
+    const capture = row2.dead ? { ok: true, stdout: "" } : await run(runner, buildCapture(row2.session));
+    const tail2 = capture.ok ? capture.stdout : "";
+    const nextHash = hashTail(tail2);
+    const changed = previousHashes.has(row2.session) && previousHashes.get(row2.session) !== nextHash;
+    hashes.set(row2.session, nextHash);
+    const derived = deriveStatus({ dead: row2.dead, tail: tail2, changed });
+    agents.push({
+      name: row2.name,
+      session: row2.session,
+      harness: row2.harness,
+      space: row2.space,
+      backend: row2.backend,
+      status: derived.status,
+      ask: derived.ask
+    });
+  }
+  return { agents, hashes };
+}
+var BLOCK_MARKERS;
+var init_model = __esm({
+  "cli/ui/model.ts"() {
+    "use strict";
+    init_tmux();
+    BLOCK_MARKERS = [
+      { pattern: /needs a tracking decision|Task tracking suggestion|tracking decision for "/i, ask: "tracking" },
+      { pattern: /\[synkro:task-workspace|\[synkro:scm|keep working in the current workspace/i, ask: "workspace" },
+      { pattern: /⛔/, ask: "tracking" }
+    ];
+  }
+});
+
+// cli/ui/consent.ts
+function actionsForAsk(ask3) {
+  return ask3 === "workspace" ? ["stay"] : ["track", "skip"];
+}
+var CONSENT_PHRASES;
+var init_consent = __esm({
+  "cli/ui/consent.ts"() {
+    "use strict";
+    CONSENT_PHRASES = {
+      /** Settles the conductor tracking ask by durable decline. */
+      skip: "skip the task tracking, continue without a task",
+      /** Settles the task-workspace ask in place. */
+      stay: "stay in the current worktree",
+      /** Asks the agent to run the two-phase create flow (draft → approve). */
+      track: "yes, track this work \u2014 draft the requirements and create the task"
+    };
+  }
+});
+
+// cli/ui/render.ts
+function pad(text, width) {
+  return text.length >= width ? text.slice(0, width) : text + " ".repeat(width - text.length);
+}
+function row(selected, width, content) {
+  const body = stripForPad(" " + content, width);
+  return selected ? STYLE.select + body + STYLE.reset : body;
+}
+function stripForPad(text, width) {
+  let visible = 0;
+  let out = "";
+  let index = 0;
+  while (index < text.length && visible < width) {
+    if (text.startsWith(ESC, index)) {
+      const end = text.indexOf("m", index);
+      if (end === -1) break;
+      out += text.slice(index, end + 1);
+      index = end + 1;
+    } else {
+      out += text[index];
+      index += 1;
+      visible += 1;
+    }
+  }
+  return out + " ".repeat(Math.max(0, width - visible));
+}
+function renderSidebar(state, width = 32, height = 40) {
+  const lines = [];
+  lines.push("");
+  lines.push(" " + STYLE.header + "spaces" + STYLE.reset);
+  lines.push("");
+  state.spaces.forEach((space, index) => {
+    const selected = state.section === "spaces" && index === state.spaceIndex;
+    const badge = space.backend === "container" ? STYLE.accent + "\u25A3 " + STYLE.reset : "";
+    lines.push(row(selected, width, STYLE.done + "\u25CF" + STYLE.reset + " " + badge + STYLE.bold + space.name + STYLE.reset));
+    lines.push(row(selected, width, "  " + STYLE.branch + space.branch + STYLE.reset));
+  });
+  if (state.spaces.length === 0) lines.push(row(false, width, STYLE.dim + "no spaces found" + STYLE.reset));
+  lines.push("");
+  lines.push(" " + STYLE.header + "agents" + STYLE.reset);
+  lines.push("");
+  state.agents.forEach((agent, index) => {
+    const selected = state.section === "agents" && index === state.agentIndex;
+    const dot = DOT[agent.status] || DOT.idle;
+    const badge = agent.backend === "container" ? STYLE.accent + "\u25A3 " + STYLE.reset : "";
+    const linear = agent.linear ? "  " + STYLE.dim + agent.linear + STYLE.reset : "";
+    lines.push(row(selected, width, dot + " " + badge + STYLE.bold + agent.name + STYLE.reset + linear));
+    const statusStyle = agent.status === "blocked" ? STYLE.blocked : STYLE.dim;
+    lines.push(row(selected, width, "  " + statusStyle + agent.status + STYLE.reset + STYLE.dim + " \xB7 " + agent.harness + STYLE.reset));
+  });
+  if (state.agents.length === 0) lines.push(row(false, width, STYLE.dim + "no agents \u2014 n to spawn" + STYLE.reset));
+  const selectedAgent = state.section === "agents" ? state.agents[state.agentIndex] : void 0;
+  if (selectedAgent?.status === "blocked" && selectedAgent.ask) {
+    lines.push("");
+    lines.push(row(false, width, STYLE.blocked + "\u26D4 needs consent" + STYLE.reset));
+    for (const action of actionsForAsk(selectedAgent.ask)) {
+      const key = action === "track" ? "g" : action === "skip" ? "s" : "y";
+      lines.push(row(false, width, STYLE.dim + "  " + key + " \u2014 " + action + STYLE.reset));
+    }
+  }
+  while (lines.length < height - 4) lines.push(pad("", width));
+  lines.push(pad("", width));
+  if (state.message) lines.push(row(false, width, STYLE.accent + state.message.slice(0, width - 2) + STYLE.reset));
+  else lines.push(row(false, width, STYLE.dim + "n new \xB7 enter attach \xB7 x kill" + STYLE.reset));
+  lines.push(row(false, width, STYLE.dim + "T tab \xB7 i interrupt \xB7 q quit" + STYLE.reset));
+  lines.push(row(false, width, STYLE.dim + state.backendNote + STYLE.reset));
+  return lines.slice(0, height).join("\n");
+}
+var ESC, STYLE, DOT;
+var init_render = __esm({
+  "cli/ui/render.ts"() {
+    "use strict";
+    init_consent();
+    ESC = "\x1B[";
+    STYLE = {
+      reset: ESC + "0m",
+      dim: ESC + "2m",
+      bold: ESC + "1m",
+      header: ESC + "38;5;245m",
+      select: ESC + "48;5;236m",
+      working: ESC + "38;5;214m",
+      idle: ESC + "38;5;244m",
+      blocked: ESC + "38;5;203m",
+      done: ESC + "38;5;114m",
+      accent: ESC + "38;5;135m",
+      branch: ESC + "38;5;140m"
+    };
+    DOT = {
+      working: STYLE.working + "\u25CF" + STYLE.reset,
+      idle: STYLE.idle + "\u25CB" + STYLE.reset,
+      blocked: STYLE.blocked + "\u25CF" + STYLE.reset,
+      done: STYLE.done + "\u25CF" + STYLE.reset
+    };
+  }
+});
+
+// cli/ui/pueue.ts
+function buildEnsureGroup() {
+  return ["pueue", "group", "add", PUEUE_GROUP];
+}
+function buildGroupParallel() {
+  return ["pueue", "parallel", "-g", PUEUE_GROUP, "32"];
+}
+function buildSentinel(session) {
+  const loop = "while tmux has-session -t " + shellQuote3(session) + " 2>/dev/null; do sleep 10; done";
+  return ["pueue", "add", "-g", PUEUE_GROUP, "-l", session, "--", loop];
+}
+function buildRemove(taskId) {
+  return ["pueue", "remove", taskId];
+}
+async function pueueAvailable2(runner) {
+  const result = await run(runner, ["sh", "-c", "command -v pueue >/dev/null 2>&1 && pueue status >/dev/null 2>&1 && echo ok"]);
+  return result.ok && result.stdout.includes("ok");
+}
+async function registerAgent(runner, session) {
+  if (!await pueueAvailable2(runner)) return "";
+  await run(runner, buildEnsureGroup());
+  await run(runner, buildGroupParallel());
+  const added = await run(runner, buildSentinel(session));
+  const match = added.stdout.match(/id\s+(\d+)/i) || added.stderr.match(/id\s+(\d+)/i);
+  return match ? match[1] : "";
+}
+async function releaseAgent(runner, pueueId) {
+  if (!pueueId) return;
+  await run(runner, buildRemove(pueueId)).catch?.(() => {
+  });
+}
+var PUEUE_GROUP;
+var init_pueue2 = __esm({
+  "cli/ui/pueue.ts"() {
+    "use strict";
+    init_tmux();
+    PUEUE_GROUP = "synkro-ui";
+  }
+});
+
+// cli/ui/backend.ts
+async function detectContainerBackend() {
+  const runner = { kind: "container", container: CONTAINER_NAME2 };
+  const probe = await run({ kind: "host" }, [
+    "docker",
+    "exec",
+    CONTAINER_NAME2,
+    "sh",
+    "-c",
+    "command -v tmux >/dev/null && command -v claude >/dev/null && ls " + shellQuote3(AUTH_SEED) + " >/dev/null 2>&1 && echo ready"
+  ]);
+  if (probe.ok && probe.stdout.includes("ready")) {
+    return { runner, backend: "container", note: "runtime: container (" + CONTAINER_NAME2 + ")" };
+  }
+  return { runner: { kind: "host" }, backend: "host", note: "runtime: host (container unavailable)" };
+}
+async function provisionContainerWorkspace(runner, slug) {
+  const dir = CONTAINER_WORK + "/ui-" + slug;
+  await run(runner, [
+    "sh",
+    "-c",
+    "mkdir -p " + shellQuote3(dir) + " && cp -n " + shellQuote3(AUTH_SEED) + " " + shellQuote3(dir + "/.claude.json") + " 2>/dev/null; true"
+  ]);
+  return dir;
+}
+async function spawnAgent(info, request) {
+  const slug = slugify(request.name);
+  const session = agentSession(slug);
+  const runner = request.backend === "container" ? { kind: "container", container: CONTAINER_NAME2 } : { kind: "host" };
+  let cwd = request.cwd;
+  if (request.backend === "container") {
+    cwd = request.cwd.startsWith(CONTAINER_WORK) ? request.cwd : await provisionContainerWorkspace(runner, slug);
+  }
+  const command = request.harness === "codex" ? "codex" : "claude";
+  for (const argv of buildSpawnAgent({ name: slug, cwd, command, harness: request.harness, space: request.spaceName, backend: request.backend })) {
+    const result = await run(runner, argv);
+    if (!result.ok && argv[1] === "new-session") {
+      return { ok: false, session, error: result.stderr.trim() || "tmux new-session failed" };
+    }
+  }
+  const pueueId = await registerAgent(runner, session);
+  if (pueueId) await run(runner, buildSetOption(session, "@synkro_pueue", pueueId));
+  return { ok: true, session };
+}
+async function killAgent(backend, session, pueueId) {
+  const runner = backend === "container" ? { kind: "container", container: CONTAINER_NAME2 } : { kind: "host" };
+  await run(runner, buildKillSession(session));
+  await releaseAgent(runner, pueueId);
+}
+var CONTAINER_NAME2, CONTAINER_WORK, AUTH_SEED;
+var init_backend = __esm({
+  "cli/ui/backend.ts"() {
+    "use strict";
+    init_tmux();
+    init_pueue2();
+    CONTAINER_NAME2 = "synkro-server";
+    CONTAINER_WORK = "/home/synkro/work";
+    AUTH_SEED = CONTAINER_WORK + "/claude-1/.claude.json";
+  }
+});
+
+// cli/ui/sidebar.ts
+function runnerFor(backend) {
+  return backend === "container" ? { kind: "container", container: CONTAINER_NAME2 } : { kind: "host" };
+}
+async function runSidebar() {
+  const centerPane = process.env.SYNKRO_UI_CENTER || "";
+  const outerSession = process.env.SYNKRO_UI_OUTER || "synkro-ui";
+  const bootPath = process.env.SYNKRO_UI_BOOT || process.argv[1];
+  const repoCwd = process.env.SYNKRO_UI_REPO || process.cwd();
+  const info = await detectContainerBackend();
+  const state = {
+    spaces: [],
+    agents: [],
+    section: "agents",
+    spaceIndex: 0,
+    agentIndex: 0,
+    backendNote: info.note,
+    message: ""
+  };
+  let hashes = /* @__PURE__ */ new Map();
+  let lastFrame = "";
+  let spawnCounter = 1;
+  const host = { kind: "host" };
+  const containerRunner = { kind: "container", container: CONTAINER_NAME2 };
+  async function refresh() {
+    const [hostSpaces, containerSpaces, conductorTasks] = await Promise.all([
+      discoverHostSpaces(repoCwd),
+      info.backend === "container" ? discoverContainerSpaces(containerRunner) : Promise.resolve([]),
+      fetchConductorTasks(CONDUCTOR_URL)
+    ]);
+    state.spaces = [...hostSpaces, ...containerSpaces];
+    const hostAgents = await discoverAgents(host, "host", hashes);
+    const containerAgents = info.backend === "container" ? await discoverAgents(containerRunner, "container", hashes) : { agents: [], hashes: /* @__PURE__ */ new Map() };
+    hashes = new Map([...hostAgents.hashes, ...containerAgents.hashes]);
+    state.agents = [...hostAgents.agents, ...containerAgents.agents].map((agent) => ({
+      ...agent,
+      linear: mapAgentToTask(agent.space, conductorTasks)
+    }));
+    state.spaceIndex = Math.min(state.spaceIndex, Math.max(0, state.spaces.length - 1));
+    state.agentIndex = Math.min(state.agentIndex, Math.max(0, state.agents.length - 1));
+  }
+  function draw() {
+    const rows = Number(process.stdout.rows || 42);
+    const cols = Number(process.stdout.columns || 32);
+    const frame = renderSidebar(state, cols, rows);
+    if (frame === lastFrame) return;
+    lastFrame = frame;
+    process.stdout.write("\x1B[2J\x1B[H" + frame);
+  }
+  async function attachSelected() {
+    const agent = state.agents[state.agentIndex];
+    if (!agent || !centerPane) return;
+    const command = buildCenterAttachCommand(runnerFor(agent.backend), agent.session);
+    await run(host, ["tmux", "respawn-pane", "-k", "-t", centerPane, command]);
+    await run(host, ["tmux", "rename-window", "-t", outerSession, agent.name]);
+    state.message = "attached " + agent.name;
+  }
+  async function spawnInSelectedSpace() {
+    const space = state.spaces[state.spaceIndex] || state.spaces[0];
+    if (!space) {
+      state.message = "no space selected";
+      return;
+    }
+    const name = space.name + "-" + spawnCounter++;
+    const result = await spawnAgent(info, {
+      name,
+      harness: "claude",
+      spaceName: space.name,
+      cwd: space.path,
+      backend: space.backend === "container" && info.backend === "container" ? "container" : "host"
+    });
+    state.message = result.ok ? "spawned " + name : "spawn failed: " + (result.error || "").slice(0, 24);
+  }
+  async function spawnContainerAgent() {
+    if (info.backend !== "container") {
+      state.message = "container runtime unavailable";
+      return;
+    }
+    const name = "box-" + spawnCounter++;
+    const result = await spawnAgent(info, { name, harness: "claude", spaceName: name, cwd: "", backend: "container" });
+    state.message = result.ok ? "spawned \u25A3 " + name : "spawn failed: " + (result.error || "").slice(0, 24);
+  }
+  async function consent(action) {
+    const agent = state.agents[state.agentIndex];
+    if (!agent || agent.status !== "blocked" || !agent.ask) return;
+    if (!actionsForAsk(agent.ask).includes(action)) return;
+    const runner = runnerFor(agent.backend);
+    for (const argv of buildSendText(agent.session, CONSENT_PHRASES[action])) await run(runner, argv);
+    state.message = action + " \u2192 " + agent.name;
+  }
+  async function newTab() {
+    await run(host, ["node", String(bootPath), "ui", "--new-tab", outerSession]);
+  }
+  process.stdin.setRawMode?.(true);
+  process.stdin.resume();
+  process.stdin.on("data", (chunk) => {
+    const key = chunk.toString("utf8");
+    void (async () => {
+      const list = state.section === "spaces" ? state.spaces : state.agents;
+      if (key === "	") state.section = state.section === "spaces" ? "agents" : "spaces";
+      else if (key === "j" || key === "\x1B[B") {
+        if (state.section === "spaces") state.spaceIndex = Math.min(state.spaceIndex + 1, Math.max(0, list.length - 1));
+        else state.agentIndex = Math.min(state.agentIndex + 1, Math.max(0, list.length - 1));
+      } else if (key === "k" || key === "\x1B[A") {
+        if (state.section === "spaces") state.spaceIndex = Math.max(0, state.spaceIndex - 1);
+        else state.agentIndex = Math.max(0, state.agentIndex - 1);
+      } else if (key === "\r") {
+        if (state.section === "agents") await attachSelected();
+        else state.message = "space: " + (state.spaces[state.spaceIndex]?.name || "");
+      } else if (key === "n") await spawnInSelectedSpace();
+      else if (key === "c") await spawnContainerAgent();
+      else if (key === "x") {
+        const agent = state.agents[state.agentIndex];
+        if (agent) {
+          await killAgent(agent.backend, agent.session, "");
+          state.message = "killed " + agent.name;
+        }
+      } else if (key === "i") {
+        const agent = state.agents[state.agentIndex];
+        if (agent) await run(runnerFor(agent.backend), buildInterrupt(agent.session));
+      } else if (key === "g") await consent("track");
+      else if (key === "s") await consent("skip");
+      else if (key === "y") await consent("stay");
+      else if (key === "T") await newTab();
+      else if (key === "q" || key === "") {
+        await run(host, ["tmux", "kill-session", "-t", outerSession]);
+        process.exit(0);
+      }
+      await refresh();
+      draw();
+    })();
+  });
+  await refresh();
+  draw();
+  setInterval(() => {
+    void refresh().then(draw);
+  }, POLL_MS);
+}
+var POLL_MS, CONDUCTOR_URL;
+var init_sidebar = __esm({
+  "cli/ui/sidebar.ts"() {
+    "use strict";
+    init_model();
+    init_render();
+    init_consent();
+    init_backend();
+    init_tmux();
+    POLL_MS = 2e3;
+    CONDUCTOR_URL = "http://127.0.0.1:" + (process.env.SYNKRO_HOST_MCP_PORT || "18931");
+  }
+});
+
+// cli/commands/ui.ts
+var ui_exports = {};
+__export(ui_exports, {
+  uiCommand: () => uiCommand
+});
+import { execSync as execSync7 } from "child_process";
+function repoRoot() {
+  try {
+    return execSync7("git rev-parse --show-toplevel", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim() || process.cwd();
+  } catch {
+    return process.cwd();
+  }
+}
+function tmuxPresent() {
+  try {
+    execSync7("tmux -V", { stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function uiCommand(args2) {
+  const bootPath = String(process.argv[1] || "");
+  if (args2.includes("--sidebar")) {
+    await runSidebar();
+    await new Promise(() => {
+    });
+    return;
+  }
+  if (args2.includes("--new-tab")) {
+    await buildTab(bootPath, repoRoot(), "new");
+    return;
+  }
+  if (!tmuxPresent()) {
+    console.error("synkro ui needs tmux. Install it (brew install tmux) and rerun.");
+    process.exitCode = 1;
+    return;
+  }
+  const code = await launchUi(bootPath, repoRoot());
+  process.exitCode = code;
+}
+var init_ui = __esm({
+  "cli/commands/ui.ts"() {
+    "use strict";
+    init_launch();
+    init_sidebar();
+  }
+});
+
+// cli/commands/refresh.ts
+var refresh_exports = {};
+__export(refresh_exports, {
+  refreshCommand: () => refreshCommand
+});
+async function refreshCommand(args2 = []) {
+  const json = args2.includes("--json");
+  const creds = loadCredentials();
+  if (!creds?.refresh_token) {
+    if (json) console.log(JSON.stringify({ refreshed: false, reason: "no refresh_token" }));
+    else console.error("Not logged in (no refresh_token) \u2014 run `synkro login`.");
+    process.exit(1);
+  }
+  const ok = await refreshToken();
+  if (json) {
+    console.log(JSON.stringify({ refreshed: ok }));
+  } else if (ok) {
+    console.log("\u2713 Synkro session refreshed.");
+  } else {
+    console.error("Could not refresh \u2014 the refresh_token may be revoked. Run `synkro login`.");
+  }
+  if (!ok) process.exit(1);
+}
+var init_refresh = __esm({
+  "cli/commands/refresh.ts"() {
+    "use strict";
+    init_stub();
+  }
+});
+
+// cli/commands/linear.ts
+var linear_exports = {};
+__export(linear_exports, {
+  formatLinks: () => formatLinks,
+  linearCommand: () => linearCommand
+});
+import { readFileSync as readFileSync30 } from "fs";
+import { homedir as homedir32 } from "os";
+import { join as join32 } from "path";
+function mcpJwt() {
+  try {
+    return readFileSync30(join32(SYNKRO_DIR14, ".mcp-jwt"), "utf-8").trim();
+  } catch {
+    return "";
+  }
 }
 function formatLinks(links) {
   if (!links.length) return "No Linear-linked work yet. The conductor links a ticket when you start a tracked task.";
@@ -13533,7 +15215,7 @@ var SYNKRO_DIR14, PORT2, BASE;
 var init_linear = __esm({
   "cli/commands/linear.ts"() {
     "use strict";
-    SYNKRO_DIR14 = join31(homedir31(), ".synkro");
+    SYNKRO_DIR14 = join32(homedir32(), ".synkro");
     PORT2 = process.env.SYNKRO_MCP_PORT || "18931";
     BASE = `http://127.0.0.1:${PORT2}`;
   }
@@ -13682,33 +15364,33 @@ var init_cveReachability = __esm({
 });
 
 // cli/reachability/reachabilityScan.ts
-import { spawnSync as spawnSync11, execFileSync as execFileSync5 } from "child_process";
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync22, existsSync as existsSync33, readdirSync as readdirSync8 } from "fs";
-import { join as join32 } from "path";
-import { homedir as homedir32 } from "os";
+import { spawnSync as spawnSync12, execFileSync as execFileSync5 } from "child_process";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync23, existsSync as existsSync34, readdirSync as readdirSync9 } from "fs";
+import { join as join33 } from "path";
+import { homedir as homedir33 } from "os";
 import { createRequire } from "module";
-function walkSourceFiles(repoRoot2, maxFiles = 4e3, maxBytes = 5e5) {
+function walkSourceFiles(repoRoot3, maxFiles = 4e3, maxBytes = 5e5) {
   const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage", ".next", ".turbo", "out", ".cache", ".synkro", ".claude", "vendor", "__tests__", "test-results"]);
   const EXT = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
   const files = [];
-  const stack = [repoRoot2];
+  const stack = [repoRoot3];
   while (stack.length && files.length < maxFiles) {
     const dir = stack.pop();
     let ents;
     try {
-      ents = readdirSync8(dir, { withFileTypes: true });
+      ents = readdirSync9(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of ents) {
       if (files.length >= maxFiles) break;
-      const full = join32(dir, e.name);
+      const full = join33(dir, e.name);
       if (e.isDirectory()) {
         if (!SKIP.has(e.name) && !e.name.startsWith(".")) stack.push(full);
         continue;
       }
       if (!EXT.test(e.name) || e.name.endsWith(".d.ts")) continue;
-      const rel = full.startsWith(repoRoot2 + "/") ? full.slice(repoRoot2.length + 1) : full;
+      const rel = full.startsWith(repoRoot3 + "/") ? full.slice(repoRoot3.length + 1) : full;
       try {
         const content = readFileSync32(full, "utf8");
         if (content.length <= maxBytes) files.push({ path: rel, content });
@@ -13726,15 +15408,15 @@ function cleanVersion(spec) {
   const c = s.replace(/^[\^~>=<\s]+/, "");
   return /^\d[\w.\-+]*$/.test(c) ? c : null;
 }
-function gatherManifestVersions(repoRoot2) {
+function gatherManifestVersions(repoRoot3) {
   const out = {};
-  const dirs = [repoRoot2];
-  const pkgsDir = join32(repoRoot2, "packages");
-  if (existsSync33(pkgsDir)) {
+  const dirs = [repoRoot3];
+  const pkgsDir = join33(repoRoot3, "packages");
+  if (existsSync34(pkgsDir)) {
     try {
-      for (const d of readdirSync8(pkgsDir)) {
-        const pd = join32(pkgsDir, d);
-        if (existsSync33(join32(pd, "package.json"))) dirs.push(pd);
+      for (const d of readdirSync9(pkgsDir)) {
+        const pd = join33(pkgsDir, d);
+        if (existsSync34(join33(pd, "package.json"))) dirs.push(pd);
       }
     } catch {
     }
@@ -13743,7 +15425,7 @@ function gatherManifestVersions(repoRoot2) {
   for (const dir of dirs) {
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync32(join32(dir, "package.json"), "utf8"));
+      pkg = JSON.parse(readFileSync32(join33(dir, "package.json"), "utf8"));
     } catch {
       continue;
     }
@@ -13759,32 +15441,32 @@ function gatherManifestVersions(repoRoot2) {
   }
   return out;
 }
-function findJelly(repoRoot2) {
+function findJelly(repoRoot3) {
   try {
     const pkgJson = require2.resolve("@cs-au-dk/jelly/package.json");
     const dir = pkgJson.slice(0, pkgJson.length - "package.json".length);
     const pkg = JSON.parse(readFileSync32(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 = join32(dir, bin);
-      if (existsSync33(p)) return p;
+      const p = join33(dir, bin);
+      if (existsSync34(p)) return p;
     }
   } catch {
   }
-  for (const base of [repoRoot2, process.cwd()]) {
-    const b = join32(base, "node_modules", ".bin", "jelly");
-    if (existsSync33(b)) return b;
+  for (const base of [repoRoot3, process.cwd()]) {
+    const b = join33(base, "node_modules", ".bin", "jelly");
+    if (existsSync34(b)) return b;
   }
   return null;
 }
-function findEntries(repoRoot2) {
-  const dirs = [repoRoot2];
-  const pkgsDir = join32(repoRoot2, "packages");
-  if (existsSync33(pkgsDir)) {
+function findEntries(repoRoot3) {
+  const dirs = [repoRoot3];
+  const pkgsDir = join33(repoRoot3, "packages");
+  if (existsSync34(pkgsDir)) {
     try {
-      for (const d of readdirSync8(pkgsDir)) {
-        const pd = join32(pkgsDir, d);
-        if (existsSync33(join32(pd, "package.json"))) dirs.push(pd);
+      for (const d of readdirSync9(pkgsDir)) {
+        const pd = join33(pkgsDir, d);
+        if (existsSync34(join33(pd, "package.json"))) dirs.push(pd);
       }
     } catch {
     }
@@ -13792,12 +15474,12 @@ function findEntries(repoRoot2) {
   const entries = [];
   for (const dir of dirs) {
     try {
-      const pkg = JSON.parse(readFileSync32(join32(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync32(join33(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 = join32(dir, c);
-        if (existsSync33(f)) {
+        const f = join33(dir, c);
+        if (existsSync34(f)) {
           entries.push(f);
           break;
         }
@@ -13807,9 +15489,9 @@ function findEntries(repoRoot2) {
   }
   return entries.slice(0, 40);
 }
-function currentCommit(repoRoot2) {
+function currentCommit(repoRoot3) {
   try {
-    return execFileSync5("git", ["rev-parse", "HEAD"], { cwd: repoRoot2, encoding: "utf8" }).trim();
+    return execFileSync5("git", ["rev-parse", "HEAD"], { cwd: repoRoot3, encoding: "utf8" }).trim();
   } catch {
     return "";
   }
@@ -13828,9 +15510,9 @@ function parseApiUsage(log) {
   for (const k of Object.keys(map)) out[k] = { reachableApis: [...map[k]].slice(0, 60) };
   return out;
 }
-function runReachabilityScan(repoRoot2, opts = {}) {
-  const commit = currentCommit(repoRoot2);
-  if (!opts.force && commit && existsSync33(REACHABILITY_PATH)) {
+function runReachabilityScan(repoRoot3, opts = {}) {
+  const commit = currentCommit(repoRoot3);
+  if (!opts.force && commit && existsSync34(REACHABILITY_PATH)) {
     try {
       const prev = JSON.parse(readFileSync32(REACHABILITY_PATH, "utf8"));
       if (prev.commit === commit) return { ok: true, cached: true, packages: Object.keys(prev.packages || {}).length };
@@ -13879,13 +15561,13 @@ function runReachabilityScan(repoRoot2, opts = {}) {
     }
   };
   let tool = "ast";
-  const jelly = findJelly(repoRoot2);
+  const jelly = findJelly(repoRoot3);
   if (jelly) {
-    const entries = findEntries(repoRoot2);
+    const entries = findEntries(repoRoot3);
     if (entries.length > 0) {
-      const r = spawnSync11(
+      const r = spawnSync12(
         process.execPath,
-        [jelly, "-b", repoRoot2, "--api-usage", ...entries],
+        [jelly, "-b", repoRoot3, "--api-usage", ...entries],
         { encoding: "utf8", timeout: opts.timeoutMs ?? 18e4, maxBuffer: 2e8 }
       );
       const jp = parseApiUsage((r.stdout || "") + (r.stderr || ""));
@@ -13895,7 +15577,7 @@ function runReachabilityScan(repoRoot2, opts = {}) {
       }
     }
   }
-  const astPackages = extractAllPackageUsage(walkSourceFiles(repoRoot2));
+  const astPackages = extractAllPackageUsage(walkSourceFiles(repoRoot3));
   for (const [k, v] of Object.entries(astPackages)) {
     addAll(k, v.apis);
     addSites(k, v.sites);
@@ -13919,9 +15601,9 @@ function runReachabilityScan(repoRoot2, opts = {}) {
     packages[k] = entry;
   }
   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(repoRoot2) };
+  const file = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), commit, tool, packages, versions: gatherManifestVersions(repoRoot3) };
   try {
-    writeFileSync22(REACHABILITY_PATH, JSON.stringify(file, null, 2));
+    writeFileSync23(REACHABILITY_PATH, JSON.stringify(file, null, 2));
   } catch (e) {
     return { ok: false, reason: "write failed: " + String(e.message || e) };
   }
@@ -13933,7 +15615,7 @@ var init_reachabilityScan = __esm({
     "use strict";
     init_cveReachability();
     require2 = createRequire(import.meta.url);
-    REACHABILITY_PATH = join32(homedir32(), ".synkro", "reachability.json");
+    REACHABILITY_PATH = join33(homedir33(), ".synkro", "reachability.json");
   }
 });
 
@@ -13942,13 +15624,13 @@ var reachabilityScan_exports = {};
 __export(reachabilityScan_exports, {
   reachabilityScanCommand: () => reachabilityScanCommand
 });
-import { readFileSync as readFileSync33, existsSync as existsSync34 } from "fs";
-import { join as join33 } from "path";
-import { homedir as homedir33 } from "os";
+import { readFileSync as readFileSync33, existsSync as existsSync35 } from "fs";
+import { join as join34 } from "path";
+import { homedir as homedir34 } from "os";
 import { execFileSync as execFileSync6 } from "child_process";
 function readConfigEnv4() {
-  const p = join33(SYNKRO_DIR15, "config.env");
-  if (!existsSync34(p)) return {};
+  const p = join34(SYNKRO_DIR15, "config.env");
+  if (!existsSync35(p)) return {};
   const out = {};
   for (const line of readFileSync33(p, "utf-8").split("\n")) {
     const t = line.trim();
@@ -13958,7 +15640,7 @@ function readConfigEnv4() {
   }
   return out;
 }
-function repoRoot() {
+function repoRoot2() {
   try {
     return execFileSync6("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" }).trim();
   } catch {
@@ -13966,14 +15648,14 @@ function repoRoot() {
   }
 }
 function repoSlug(root) {
-  const run = (a) => {
+  const run2 = (a) => {
     try {
       return execFileSync6("git", a, { encoding: "utf-8" }).trim();
     } catch {
       return "";
     }
   };
-  const remote = run(["remote", "get-url", "origin"]);
+  const remote = run2(["remote", "get-url", "origin"]);
   if (remote) return remote.replace(/^git@[^:]+:/, "").replace(/^https?:\/\/[^/]+\//, "").replace(/\.git$/, "");
   return root.split("/").pop() || root;
 }
@@ -13982,10 +15664,10 @@ async function pushToCloud(cfg, repo) {
   while (gwBase.endsWith("/")) gwBase = gwBase.slice(0, -1);
   let jwt2 = "";
   try {
-    jwt2 = readFileSync33(join33(SYNKRO_DIR15, ".mcp-jwt"), "utf-8").trim();
+    jwt2 = readFileSync33(join34(SYNKRO_DIR15, ".mcp-jwt"), "utf-8").trim();
   } catch {
   }
-  if (!jwt2 || !existsSync34(REACHABILITY_PATH)) return;
+  if (!jwt2 || !existsSync35(REACHABILITY_PATH)) return;
   const body = readFileSync33(REACHABILITY_PATH, "utf-8");
   try {
     const resp = await fetch(gwBase + "/api/v1/reachability?repo=" + encodeURIComponent(repo), {
@@ -14000,7 +15682,7 @@ async function pushToCloud(cfg, repo) {
   }
 }
 async function reachabilityScanCommand(args2 = []) {
-  const root = repoRoot();
+  const root = repoRoot2();
   const force = args2.includes("--force");
   const quiet = args2.includes("--quiet");
   const res = runReachabilityScan(root, { force });
@@ -14018,7 +15700,7 @@ var init_reachabilityScan2 = __esm({
   "cli/commands/reachabilityScan.ts"() {
     "use strict";
     init_reachabilityScan();
-    SYNKRO_DIR15 = join33(homedir33(), ".synkro");
+    SYNKRO_DIR15 = join34(homedir34(), ".synkro");
   }
 });
 
@@ -14148,11 +15830,11 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync23, existsSync as existsSync35 } from "fs";
-import { join as join34 } from "path";
-import { homedir as homedir34 } from "os";
+import { readFileSync as readFileSync34, writeFileSync as writeFileSync24, existsSync as existsSync36 } from "fs";
+import { join as join35 } from "path";
+import { homedir as homedir35 } from "os";
 function readConfigEnv5() {
-  if (!existsSync35(CONFIG_PATH9)) return {};
+  if (!existsSync36(CONFIG_PATH9)) return {};
   const out = {};
   for (const line of readFileSync34(CONFIG_PATH9, "utf-8").split("\n")) {
     const t = line.trim();
@@ -14163,7 +15845,7 @@ function readConfigEnv5() {
   return out;
 }
 function updateConfigValue(key, value) {
-  if (!existsSync35(CONFIG_PATH9)) {
+  if (!existsSync36(CONFIG_PATH9)) {
     console.error("No config found. Run `synkro install` first.");
     process.exit(1);
   }
@@ -14178,7 +15860,7 @@ function updateConfigValue(key, value) {
     return line;
   });
   if (!found) updated.splice(updated.length - 1, 0, `${key}='${value}'`);
-  writeFileSync23(CONFIG_PATH9, updated.join("\n"), "utf-8");
+  writeFileSync24(CONFIG_PATH9, updated.join("\n"), "utf-8");
 }
 function resolveInferenceMode(cfg) {
   if ((cfg.SYNKRO_GRADING_MODE || "local") === "byok") return "byok";
@@ -14336,8 +16018,8 @@ var init_config = __esm({
     "use strict";
     init_stub();
     init_optout();
-    SYNKRO_DIR16 = join34(homedir34(), ".synkro");
-    CONFIG_PATH9 = join34(SYNKRO_DIR16, "config.env");
+    SYNKRO_DIR16 = join35(homedir35(), ".synkro");
+    CONFIG_PATH9 = join35(SYNKRO_DIR16, "config.env");
   }
 });
 
@@ -14401,11 +16083,11 @@ async function printTail(args2) {
     console.log("(no events \u2014 run `synkro start` if the container is down so JSONL pending events can drain)");
     return;
   }
-  for (const row of rows) {
-    const session = row.cc_session_id ? ` session=${String(row.cc_session_id).slice(0, 8)}` : "";
-    const ts = typeof row.occurred_at === "string" ? row.occurred_at : new Date(row.occurred_at).toISOString();
-    console.log(`  ${ts}  ${row.event_type.padEnd(20)} ${row.emitter}${session}`);
-    const contextStr = typeof row.context === "string" ? row.context : JSON.stringify(row.context);
+  for (const row2 of rows) {
+    const session = row2.cc_session_id ? ` session=${String(row2.cc_session_id).slice(0, 8)}` : "";
+    const ts = typeof row2.occurred_at === "string" ? row2.occurred_at : new Date(row2.occurred_at).toISOString();
+    console.log(`  ${ts}  ${row2.event_type.padEnd(20)} ${row2.emitter}${session}`);
+    const contextStr = typeof row2.context === "string" ? row2.context : JSON.stringify(row2.context);
     console.log(`     context: ${truncate2(contextStr, 200)}`);
   }
 }
@@ -14427,12 +16109,12 @@ async function runExport(args2) {
 }
 function confirmYesNo(question) {
   if (!process.stdin.isTTY) return Promise.resolve(false);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const rl = createInterface5({ input: process.stdin, output: process.stdout });
     rl.question(`${question} (y/N): `, (answer) => {
       rl.close();
       const t = answer.trim().toLowerCase();
-      resolve6(t === "y" || t === "yes");
+      resolve7(t === "y" || t === "yes");
     });
   });
 }
@@ -14525,15 +16207,824 @@ Usage:
   }
 });
 
+// cli/inventory/identity.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync37, mkdirSync as mkdirSync20, readFileSync as readFileSync35, renameSync as renameSync9, writeFileSync as writeFileSync25 } from "fs";
+import { homedir as homedir36 } from "os";
+import { dirname as dirname9, join as join36 } from "path";
+function operationalIdentityPath() {
+  return process.env.SYNKRO_OPERATIONAL_IDENTITY_PATH || join36(homedir36(), ".synkro", "installation.json");
+}
+function validIdentity(value) {
+  if (!value || typeof value !== "object") return false;
+  const row2 = 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) {
+  mkdirSync20(dirname9(path), { recursive: true, mode: 448 });
+  const temp = `${path}.${process.pid}.${randomUUID5()}.tmp`;
+  writeFileSync25(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 (existsSync37(path)) {
+    try {
+      const parsed = JSON.parse(readFileSync35(path, "utf8"));
+      if (validIdentity(parsed)) {
+        cached4.set(path, parsed);
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  const identity = { installation_id: randomUUID5(), created_at: (/* @__PURE__ */ new Date()).toISOString() };
+  writeIdentity(path, identity);
+  cached4.set(path, identity);
+  return identity;
+}
+var UUID_RE, cached4;
+var init_identity2 = __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;
+    cached4 = /* @__PURE__ */ new Map();
+  }
+});
+
+// cli/inventory/collector.ts
+import { createHash as createHash5 } from "crypto";
+import {
+  existsSync as existsSync38,
+  readFileSync as readFileSync36,
+  readdirSync as readdirSync10,
+  statSync as statSync5
+} from "fs";
+import { arch, homedir as homedir37, hostname as hostname2, platform as platform5, release } from "os";
+import { basename as basename3, join as join37, relative, resolve as resolve5 } from "path";
+import { fileURLToPath } from "url";
+function sha256(value) {
+  return createHash5("sha256").update(value).digest("hex");
+}
+function pseudonymousHostnameHash(installationId, host) {
+  return sha256(`${installationId}:${host}`).slice(0, 32);
+}
+function cliVersion() {
+  try {
+    return "1.9.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function readJson(path) {
+  try {
+    if (!existsSync38(path)) return null;
+    const parsed = JSON.parse(readFileSync36(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readText(path) {
+  try {
+    if (!existsSync38(path)) return "";
+    return readFileSync36(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function urlOrigin(raw) {
+  if (typeof raw !== "string") return void 0;
+  try {
+    const parsed = new URL(raw);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return void 0;
+    return parsed.origin;
+  } catch {
+    return void 0;
+  }
+}
+function canonical(raw) {
+  return raw.trim().toLowerCase().replace(/[\s.]+/g, "-").replace(/[^a-z0-9_:@/+-]/g, "") || "unknown";
+}
+function safePackageName(command, args2) {
+  if (typeof command !== "string" || !command.trim()) return void 0;
+  const runner = basename3(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") {
+      const candidate = pkg.trim();
+      if (/^(?:@[a-z0-9_.-]+\/)?[a-z0-9_.-]+(?:@[a-z0-9_.+~-]+)?$/i.test(candidate)) {
+        return candidate;
+      }
+      return basename3(candidate);
+    }
+  }
+  return runner;
+}
+function toolNames(entry) {
+  const raw = entry.enabledTools ?? entry.enabled_tools ?? entry.allowedTools ?? entry.allowed_tools ?? entry.tools;
+  if (!Array.isArray(raw)) return [];
+  return [...new Set(raw.map((tool) => typeof tool === "string" ? tool : tool?.name).filter((tool) => typeof tool === "string" && !!tool.trim()))];
+}
+function mcpArtifactsFromJson(harness, config, configScope = "user") {
+  if (!config || !config.mcpServers || typeof config.mcpServers !== "object") return [];
+  const artifacts = [];
+  for (const [name, raw] of Object.entries(config.mcpServers)) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const entry = raw;
+    const transport = typeof entry.type === "string" ? entry.type : entry.command ? "stdio" : entry.url ? "streamable-http" : "unknown";
+    const tools = toolNames(entry);
+    const scopeId = canonical(configScope);
+    const id = `${canonical(name)}@${scopeId}`;
+    const safeShape = {
+      name,
+      transport,
+      origin: urlOrigin(entry.url),
+      package_name: safePackageName(entry.command, entry.args),
+      enabled: entry.enabled !== false && entry.disabled !== true,
+      tools,
+      scope: configScope
+    };
+    artifacts.push({
+      harness,
+      type: "mcp_server",
+      canonical_id: id,
+      display_name: String(name),
+      enabled: safeShape.enabled,
+      config_scope: configScope,
+      transport: String(transport),
+      endpoint_origin: safeShape.origin,
+      package_name: safeShape.package_name,
+      config_hash: sha256(JSON.stringify(safeShape)),
+      metadata: tools.length ? { tool_names: tools } : void 0
+    });
+    for (const tool of tools) {
+      artifacts.push({
+        harness,
+        type: "mcp_tool",
+        canonical_id: `${id}:${canonical(tool)}`,
+        display_name: tool,
+        enabled: safeShape.enabled,
+        config_scope: configScope,
+        metadata: { source: String(name) }
+      });
+    }
+  }
+  return artifacts;
+}
+function claudeDesktopConfigCandidates(home, targetPlatform) {
+  if (targetPlatform === "darwin") {
+    return [join37(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")];
+  }
+  if (targetPlatform === "linux") {
+    return [
+      join37(home, ".config", "Claude", "claude_desktop_config.json"),
+      join37(home, ".config", "claude", "claude_desktop_config.json")
+    ];
+  }
+  if (targetPlatform === "win32" && process.env.APPDATA) {
+    return [join37(process.env.APPDATA, "Claude", "claude_desktop_config.json")];
+  }
+  return [];
+}
+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 [join37(process.env.ProgramFiles, "ClaudeCode", "managed-mcp.json")];
+  }
+  return [];
+}
+function discoveredProjectRoots(claudeState, currentDirectory, explicit = [], cursorRoots = []) {
+  const roots = /* @__PURE__ */ new Set();
+  const add = (value) => {
+    if (typeof value !== "string" || !value.trim()) return;
+    const path = resolve5(value);
+    if (existsSync38(path)) roots.add(path);
+  };
+  add(currentDirectory);
+  for (const path of explicit) add(path);
+  for (const path of cursorRoots) add(path);
+  if (claudeState?.projects && typeof claudeState.projects === "object") {
+    for (const path of Object.keys(claudeState.projects)) add(path);
+  }
+  return [...roots];
+}
+function cursorWorkspaceStorageCandidates(home, targetPlatform) {
+  if (targetPlatform === "darwin") return [join37(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage")];
+  if (targetPlatform === "linux") return [join37(home, ".config", "Cursor", "User", "workspaceStorage")];
+  if (targetPlatform === "win32" && process.env.APPDATA) {
+    return [join37(process.env.APPDATA, "Cursor", "User", "workspaceStorage")];
+  }
+  return [];
+}
+function cursorWorkspaceRoots(home, targetPlatform) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const storage of cursorWorkspaceStorageCandidates(home, targetPlatform)) {
+    if (!existsSync38(storage)) continue;
+    let entries = [];
+    try {
+      entries = readdirSync10(storage, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink?.()) continue;
+      const state = readJson(join37(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 (existsSync38(path)) roots.add(resolve5(path));
+      } catch {
+      }
+    }
+  }
+  return [...roots];
+}
+function codexMcpArtifacts(content) {
+  const artifacts = [];
+  const sections = [...content.matchAll(/^\s*\[\s*([^\]]+)\s*\]\s*$/gm)];
+  for (let index = 0; index < sections.length && artifacts.length < 1e3; index++) {
+    const section = sections[index];
+    const key = section[1].trim();
+    const root = key.match(/^mcp_servers\s*\.\s*(?:"((?:[^"\\]|\\.)+)"|'([^']+)'|([A-Za-z0-9_-]+))$/);
+    if (!root) continue;
+    let name = root[1] || root[2] || root[3];
+    if (root[1]) {
+      try {
+        name = JSON.parse(`"${root[1]}"`);
+      } catch {
+        continue;
+      }
+    }
+    const start = (section.index ?? 0) + section[0].length;
+    const end = sections[index + 1]?.index ?? content.length;
+    const block = content.slice(start, end);
+    const stringValue = (key2) => {
+      const found = block.match(new RegExp(`^\\s*${key2}\\s*=\\s*("(?:[^"\\\\]|\\\\.)*")`, "m"));
+      if (!found) return void 0;
+      try {
+        return JSON.parse(found[1]);
+      } catch {
+        return void 0;
+      }
+    };
+    const enabled = !/^\s*enabled\s*=\s*false\s*$/m.test(block);
+    const url = stringValue("url");
+    const command = stringValue("command");
+    const safeShape = { name, enabled, origin: urlOrigin(url), package_name: safePackageName(command, []) };
+    artifacts.push({
+      harness: "codex",
+      type: "mcp_server",
+      canonical_id: `${canonical(name)}@user`,
+      display_name: name,
+      enabled,
+      config_scope: "user",
+      transport: command ? "stdio" : url ? "streamable-http" : "unknown",
+      endpoint_origin: safeShape.origin,
+      package_name: safeShape.package_name,
+      config_hash: sha256(JSON.stringify(safeShape))
+    });
+  }
+  return artifacts;
+}
+function flattenHookEntries(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const record = entry;
+    if (typeof record.command === "string") out.push(record);
+    if (Array.isArray(record.hooks)) out.push(...flattenHookEntries(record.hooks));
+  }
+  return out;
+}
+function hookArtifacts(harness, config) {
+  if (!config?.hooks || typeof config.hooks !== "object") return [];
+  const artifacts = [];
+  for (const [event, rawEntries] of Object.entries(config.hooks)) {
+    for (const entry of flattenHookEntries(rawEntries)) {
+      const commandHash = sha256(entry.command);
+      const managed = entry.__synkro_managed__ === true || /[\\/]\.synkro[\\/]hooks[\\/]/.test(entry.command);
+      artifacts.push({
+        harness,
+        type: "hook",
+        canonical_id: `${canonical(event)}:${commandHash.slice(0, 20)}`,
+        display_name: `${event} \xB7 ${basename3(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,
+        config_hash: commandHash,
+        metadata: { managed, events: [event] }
+      });
+    }
+  }
+  return artifacts;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const value = (key) => match[1].match(new RegExp(`^${key}:\\s*["']?([^"'\\n]+)`, "m"))?.[1]?.trim();
+  return { name: value("name"), version: value("version") };
+}
+function skillArtifacts(harness, root) {
+  if (!existsSync38(root)) return [];
+  const manifests = [];
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync10(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink?.()) continue;
+      const path = join37(dir, entry.name);
+      if (entry.isFile() && entry.name === "SKILL.md") manifests.push(path);
+      else if (entry.isDirectory()) visit(path);
+    }
+  };
+  visit(root);
+  return manifests.map((path) => {
+    const content = readText(path);
+    const frontmatter = parseFrontmatter(content);
+    const rel = relative(root, path).replaceAll("\\", "/");
+    const name = frontmatter.name || basename3(join37(path, "..")) || "skill";
+    return {
+      harness,
+      type: "skill",
+      canonical_id: `${canonical(name)}:${sha256(rel).slice(0, 16)}`,
+      display_name: name,
+      version: frontmatter.version,
+      enabled: true,
+      config_scope: "user",
+      config_hash: content ? sha256(content) : void 0,
+      metadata: { source: "SKILL.md" }
+    };
+  });
+}
+function cursorExtensionArtifacts(root) {
+  if (!existsSync38(root)) return [];
+  let dirs = [];
+  try {
+    dirs = readdirSync10(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink());
+  } catch {
+    return [];
+  }
+  const artifacts = [];
+  for (const dir of dirs) {
+    const pkg = readJson(join37(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;
+    const id = publisher ? `${publisher}.${name}` : name;
+    artifacts.push({
+      harness: "cursor",
+      type: "extension",
+      canonical_id: canonical(id),
+      display_name: String(pkg.displayName || name),
+      version: typeof pkg.version === "string" ? pkg.version : void 0,
+      enabled: true,
+      config_scope: "user",
+      config_hash: sha256(JSON.stringify({ id, version: pkg.version })),
+      metadata: publisher ? { publisher } : void 0
+    });
+  }
+  return artifacts;
+}
+function deploymentMode2(home) {
+  const raw = readText(join37(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(join37(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 = join37(home, ".synkro", "telemetry-pending.jsonl");
+  try {
+    const size = statSync5(queue).size;
+    health.telemetry_backlog = size <= 5 * 1024 * 1024 ? readFileSync36(queue, "utf8").split("\n").filter(Boolean).length : Math.ceil(size / 1024);
+  } catch {
+  }
+  return health;
+}
+function harnessSnapshot(agent) {
+  if (agent.kind === "claude_code") {
+    const config2 = readJson(agent.settingsPath);
+    const coverage2 = inspectCCHooks(agent.settingsPath);
+    return {
+      row: {
+        harness: "claude_code",
+        installed: true,
+        enabled: coverage2.installed,
+        version: agent.version,
+        permission_mode: config2?.permissions?.defaultMode,
+        hook_coverage: coverage2,
+        hook_config_hash: sha256(JSON.stringify(coverage2)),
+        config_scope: "user"
+      },
+      config: config2
+    };
+  }
+  if (agent.kind === "cursor") {
+    const config2 = readJson(agent.settingsPath);
+    const coverage2 = inspectCursorHooks(agent.settingsPath);
+    return {
+      row: {
+        harness: "cursor",
+        installed: true,
+        enabled: coverage2.installed,
+        version: agent.version,
+        hook_coverage: coverage2,
+        hook_config_hash: sha256(JSON.stringify(coverage2)),
+        config_scope: "user"
+      },
+      config: config2
+    };
+  }
+  const config = readJson(agent.settingsPath);
+  const coverage = inspectCodexHooks(agent.settingsPath);
+  const toml = readText(join37(agent.configDir, "config.toml"));
+  const permission = toml.match(/^\s*approval_policy\s*=\s*["']([^"']+)/m)?.[1];
+  return {
+    row: {
+      harness: "codex",
+      installed: true,
+      enabled: coverage.installed,
+      version: agent.version,
+      permission_mode: permission,
+      hook_coverage: coverage,
+      hook_config_hash: sha256(JSON.stringify(coverage)),
+      config_scope: "user"
+    },
+    config
+  };
+}
+function collectOperationalInventory(options = {}) {
+  const home = options.homeDir ?? homedir37();
+  const detected = options.detectedAgents ?? detectAgents();
+  const identity = getOperationalInstallationIdentity(options.identityPath);
+  const targetPlatform = options.platformName ?? platform5();
+  const codexHome = options.homeDir ? join37(home, ".codex") : process.env.CODEX_HOME || join37(home, ".codex");
+  const harnesses = [];
+  const artifacts = [];
+  for (const agent of detected) {
+    const { row: row2, config } = harnessSnapshot(agent);
+    harnesses.push(row2);
+    artifacts.push(...hookArtifacts(row2.harness, config));
+  }
+  const claudeJson = readJson(join37(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)) {
+      if (!project || typeof project !== "object") continue;
+      artifacts.push(...mcpArtifactsFromJson("claude_code", project, `local:${sha256(projectPath).slice(0, 16)}`));
+    }
+  }
+  artifacts.push(...mcpArtifactsFromJson("cursor", readJson(join37(home, ".cursor", "mcp.json"))));
+  artifacts.push(...codexMcpArtifacts(readText(join37(codexHome, "config.toml"))));
+  const projectRoots = discoveredProjectRoots(
+    claudeJson,
+    options.currentDirectory ?? process.cwd(),
+    options.projectRoots,
+    cursorWorkspaceRoots(home, targetPlatform)
+  );
+  for (const projectRoot of projectRoots) {
+    const scopeHash = sha256(projectRoot).slice(0, 16);
+    artifacts.push(...mcpArtifactsFromJson(
+      "claude_code",
+      readJson(join37(projectRoot, ".mcp.json")),
+      `project:${scopeHash}`
+    ));
+    const cursorProjectConfig = join37(projectRoot, ".cursor", "mcp.json");
+    if (resolve5(cursorProjectConfig) !== resolve5(join37(home, ".cursor", "mcp.json"))) {
+      artifacts.push(...mcpArtifactsFromJson(
+        "cursor",
+        readJson(cursorProjectConfig),
+        `project:${scopeHash}`
+      ));
+    }
+  }
+  for (const managedPath of claudeManagedMcpConfigCandidates(targetPlatform)) {
+    artifacts.push(...mcpArtifactsFromJson("claude_code", readJson(managedPath), "managed"));
+  }
+  const desktopConfigPath = claudeDesktopConfigCandidates(home, targetPlatform).find((path) => existsSync38(path));
+  if (desktopConfigPath) {
+    const desktopConfig = readJson(desktopConfigPath);
+    harnesses.push({
+      harness: "claude_desktop",
+      installed: true,
+      enabled: true,
+      config_scope: "user"
+    });
+    artifacts.push(...mcpArtifactsFromJson("claude_desktop", desktopConfig));
+  }
+  const claudeSettings = readJson(join37(home, ".claude", "settings.json"));
+  if (claudeSettings?.enabledPlugins && typeof claudeSettings.enabledPlugins === "object") {
+    for (const [name, enabled] of Object.entries(claudeSettings.enabledPlugins)) {
+      artifacts.push({
+        harness: "claude_code",
+        type: "plugin",
+        canonical_id: canonical(name),
+        display_name: name,
+        enabled: enabled === true,
+        config_scope: "user",
+        metadata: { source: "enabledPlugins" }
+      });
+    }
+  }
+  artifacts.push(...skillArtifacts("claude_code", join37(home, ".claude", "skills")));
+  artifacts.push(...skillArtifacts("cursor", join37(home, ".cursor", "skills")));
+  artifacts.push(...skillArtifacts("codex", join37(codexHome, "skills")));
+  artifacts.push(...cursorExtensionArtifacts(join37(home, ".cursor", "extensions")));
+  const uniqueArtifacts = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts) {
+    const key = `${artifact.harness || "global"}:${artifact.type}:${artifact.canonical_id}`;
+    uniqueArtifacts.set(key, artifact);
+  }
+  const codingHarnesses = harnesses.filter((row2) => row2.harness === "claude_code" || row2.harness === "cursor" || row2.harness === "codex");
+  const health = telemetryHealth(home) ?? {};
+  health.scanners = {
+    hook_runtime: codingHarnesses.length === 0 ? "unknown" : codingHarnesses.every((row2) => row2.enabled) ? "ok" : "degraded"
+  };
+  return {
+    schema_version: 1,
+    collected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    installation: {
+      install_id: identity.installation_id,
+      hostname_hash: pseudonymousHostnameHash(identity.installation_id, hostname2()),
+      platform: targetPlatform,
+      os_version: release(),
+      arch: arch(),
+      cli_version: cliVersion(),
+      node_version: process.version,
+      bun_version: process.versions.bun,
+      deployment_mode: deploymentMode2(home)
+    },
+    harnesses,
+    artifacts: [...uniqueArtifacts.values()],
+    health
+  };
+}
+var init_collector = __esm({
+  "cli/inventory/collector.ts"() {
+    "use strict";
+    init_agentDetect();
+    init_ccHookConfig();
+    init_cursorHookConfig();
+    init_codexHookConfig();
+    init_identity2();
+  }
+});
+
+// cli/inventory/sync.ts
+var sync_exports2 = {};
+__export(sync_exports2, {
+  inventorySnapshotChunks: () => inventorySnapshotChunks,
+  inventorySyncTarget: () => inventorySyncTarget,
+  resolveInventoryGateway: () => resolveInventoryGateway,
+  resolveLocalInventoryUrl: () => resolveLocalInventoryUrl,
+  shouldSyncInventory: () => shouldSyncInventory,
+  syncOperationalInventory: () => syncOperationalInventory,
+  syncOperationalInventoryDetached: () => syncOperationalInventoryDetached
+});
+import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
+import { spawn as spawn8 } from "child_process";
+import {
+  existsSync as existsSync39,
+  mkdirSync as mkdirSync21,
+  readFileSync as readFileSync37,
+  renameSync as renameSync10,
+  writeFileSync as writeFileSync26
+} from "fs";
+import { homedir as homedir38 } from "os";
+import { dirname as dirname10, join as join38 } from "path";
+function syncStatePath() {
+  return process.env.SYNKRO_INVENTORY_SYNC_STATE_PATH || join38(homedir38(), ".synkro", "inventory-sync.json");
+}
+function readState(path = syncStatePath()) {
+  try {
+    const parsed = JSON.parse(readFileSync37(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeState(state, path = syncStatePath()) {
+  try {
+    mkdirSync21(dirname10(path), { recursive: true, mode: 448 });
+    const temp = `${path}.${process.pid}.tmp`;
+    writeFileSync26(temp, JSON.stringify(state, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+    renameSync10(temp, path);
+  } catch {
+  }
+}
+function shouldSyncInventory(state, now = Date.now(), target) {
+  if (target && state.last_target !== target) return true;
+  const lastOk = state.last_ok_at ? Date.parse(state.last_ok_at) : 0;
+  if (Number.isFinite(lastOk) && lastOk > 0 && now - lastOk < SUCCESS_INTERVAL_MS) return false;
+  const lastAttempt = state.last_attempt_at ? Date.parse(state.last_attempt_at) : 0;
+  return !Number.isFinite(lastAttempt) || lastAttempt <= 0 || now - lastAttempt >= FAILURE_RETRY_MS;
+}
+function readConfig() {
+  const path = join38(homedir38(), ".synkro", "config.env");
+  const out = {};
+  try {
+    for (const rawLine of readFileSync37(path, "utf8").split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      const index = line.indexOf("=");
+      if (index <= 0) continue;
+      const key = line.slice(0, index).trim();
+      let value = line.slice(index + 1).trim();
+      if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+      out[key] = value;
+    }
+  } catch {
+  }
+  return out;
+}
+function inventorySyncTarget(config, env = process.env) {
+  return (config.SYNKRO_STORAGE_MODE || env.SYNKRO_STORAGE_MODE) === "cloud" ? "cloud" : "local";
+}
+function resolveLocalInventoryUrl(rawPort) {
+  const parsed = Number.parseInt(rawPort || "", 10);
+  const port = Number.isInteger(parsed) && parsed >= 1 && parsed <= 65535 ? parsed : 18931;
+  return `http://127.0.0.1:${port}/api/local/inventory/snapshot`;
+}
+function localhost(host) {
+  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+function resolveInventoryGateway(raw) {
+  if (!raw) return DEFAULT_GATEWAY2;
+  try {
+    const url = new URL(raw);
+    const host = url.hostname.toLowerCase();
+    const allowedHost = localhost(host) || host === "synkro.sh" || host.endsWith(".synkro.sh");
+    const allowedProtocol = url.protocol === "https:" || url.protocol === "http:" && localhost(host);
+    return allowedHost && allowedProtocol ? raw.replace(/\/$/, "") : DEFAULT_GATEWAY2;
+  } catch {
+    return DEFAULT_GATEWAY2;
+  }
+}
+async function loadToken() {
+  try {
+    const durable = readFileSync37(join38(homedir38(), ".synkro", ".mcp-jwt"), "utf8").trim();
+    if (durable) return durable;
+  } catch {
+  }
+  try {
+    const auth = await Promise.resolve().then(() => (init_stub(), stub_exports));
+    if (!auth.isAuthenticated()) return null;
+    await auth.ensureValidToken();
+    return auth.getAccessToken();
+  } catch {
+    return null;
+  }
+}
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => [key, stable(child)]));
+}
+function inventorySnapshotChunks(snapshot, maxBytes = INVENTORY_CHUNK_BYTES) {
+  const { collected_at: _heartbeat, ...material } = snapshot;
+  const payloadHash = createHash6("sha256").update(JSON.stringify(stable(material))).digest("hex");
+  const snapshotId = randomUUID6();
+  const base = { ...snapshot, artifacts: [] };
+  const baseBytes = Buffer.byteLength(JSON.stringify(base));
+  const chunks = [];
+  let artifacts = [];
+  let bytes = baseBytes;
+  for (const artifact of snapshot.artifacts) {
+    const artifactBytes = Buffer.byteLength(JSON.stringify(artifact)) + 1;
+    if (artifacts.length > 0 && bytes + artifactBytes > maxBytes) {
+      chunks.push({ ...snapshot, artifacts });
+      artifacts = [];
+      bytes = baseBytes;
+    }
+    artifacts.push(artifact);
+    bytes += artifactBytes;
+  }
+  if (artifacts.length > 0 || chunks.length === 0) chunks.push({ ...snapshot, artifacts });
+  return { snapshotId, payloadHash, chunks };
+}
+async function postInventoryChunks(url, headers, snapshot) {
+  const delivery = inventorySnapshotChunks(snapshot);
+  let response = null;
+  for (let index = 0; index < delivery.chunks.length; index++) {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...headers,
+        "Content-Type": "application/json",
+        "X-Synkro-Inventory-Snapshot-Id": delivery.snapshotId,
+        "X-Synkro-Inventory-Payload-Hash": delivery.payloadHash,
+        "X-Synkro-Inventory-Chunk-Index": String(index),
+        "X-Synkro-Inventory-Chunk-Count": String(delivery.chunks.length),
+        "X-Synkro-Inventory-Artifact-Count": String(snapshot.artifacts.length)
+      },
+      body: JSON.stringify(delivery.chunks[index]),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+    if (!response.ok) return response;
+  }
+  return response;
+}
+async function syncOperationalInventory(options = {}) {
+  const path = syncStatePath();
+  const state = readState(path);
+  const config = readConfig();
+  const target = inventorySyncTarget(config);
+  if (!options.force && !shouldSyncInventory(state, Date.now(), target)) return { ok: true, skipped: "throttled", target };
+  const attemptedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeState({ ...state, last_attempt_at: attemptedAt, last_target: target }, path);
+  try {
+    const snapshot = collectOperationalInventory();
+    if (target === "local") {
+      const response2 = await postInventoryChunks(resolveLocalInventoryUrl(
+        process.env.SYNKRO_HOST_MCP_PORT || process.env.SYNKRO_MCP_PORT || config.SYNKRO_MCP_PORT
+      ), {}, snapshot);
+      if (!response2.ok) {
+        const error = `http_${response2.status}`;
+        writeState({ ...state, last_attempt_at: attemptedAt, last_error: error, last_target: target }, path);
+        return { ok: false, status: response2.status, error, target };
+      }
+      writeState({ last_attempt_at: attemptedAt, last_ok_at: (/* @__PURE__ */ new Date()).toISOString(), last_target: target }, path);
+      return { ok: true, status: response2.status, target };
+    }
+    const token = await loadToken();
+    if (!token) {
+      writeState({ ...state, last_attempt_at: attemptedAt, last_error: "no_auth", last_target: target }, path);
+      return { ok: false, skipped: "no_auth", target };
+    }
+    const gateway = resolveInventoryGateway(
+      process.env.SYNKRO_GATEWAY_URL || config.SYNKRO_GATEWAY_URL || process.env.SYNKRO_API_URL
+    );
+    const response = await postInventoryChunks(
+      `${gateway}/api/v1/cli/inventory/snapshot`,
+      { Authorization: `Bearer ${token}` },
+      snapshot
+    );
+    if (!response.ok) {
+      const error = `http_${response.status}`;
+      writeState({ ...state, last_attempt_at: attemptedAt, last_error: error, last_target: target }, path);
+      return { ok: false, status: response.status, error, target };
+    }
+    writeState({ last_attempt_at: attemptedAt, last_ok_at: (/* @__PURE__ */ new Date()).toISOString(), last_target: target }, path);
+    return { ok: true, status: response.status, target };
+  } catch {
+    writeState({ ...state, last_attempt_at: attemptedAt, last_error: "sync_failed", last_target: target }, path);
+    return { ok: false, error: "sync_failed", target };
+  }
+}
+function syncOperationalInventoryDetached() {
+  if (process.env.SYNKRO_INVENTORY_DETACHED === "1") return;
+  const path = syncStatePath();
+  const state = readState(path);
+  const target = inventorySyncTarget(readConfig());
+  if (!shouldSyncInventory(state, Date.now(), target)) return;
+  writeState({ ...state, last_attempt_at: (/* @__PURE__ */ new Date()).toISOString(), last_target: target }, path);
+  try {
+    const script = process.argv[1];
+    if (!script || !existsSync39(script)) return;
+    const child = spawn8(process.execPath, [script, "inventory-sync", "--detached"], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, SYNKRO_INVENTORY_DETACHED: "1" }
+    });
+    child.unref();
+  } catch {
+  }
+}
+var DEFAULT_GATEWAY2, SUCCESS_INTERVAL_MS, FAILURE_RETRY_MS, REQUEST_TIMEOUT_MS2, INVENTORY_CHUNK_BYTES;
+var init_sync2 = __esm({
+  "cli/inventory/sync.ts"() {
+    "use strict";
+    init_collector();
+    DEFAULT_GATEWAY2 = "https://api.synkro.sh";
+    SUCCESS_INTERVAL_MS = 30 * 6e4;
+    FAILURE_RETRY_MS = 5 * 6e4;
+    REQUEST_TIMEOUT_MS2 = 15e3;
+    INVENTORY_CHUNK_BYTES = 15e5;
+  }
+});
+
 // cli/bootstrap.js
-import { readFileSync as readFileSync35, existsSync as existsSync36 } from "fs";
-import { resolve as resolve5 } from "path";
+import { readFileSync as readFileSync38, existsSync as existsSync40 } from "fs";
+import { resolve as resolve6 } from "path";
 var envCandidates = [
-  resolve5(process.env.HOME ?? "", ".synkro", "config.env")
+  resolve6(process.env.HOME ?? "", ".synkro", "config.env")
 ];
 for (const envPath of envCandidates) {
-  if (!existsSync36(envPath)) continue;
-  const envContent = readFileSync35(envPath, "utf-8");
+  if (!existsSync40(envPath)) continue;
+  const envContent = readFileSync38(envPath, "utf-8");
   for (const line of envContent.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
@@ -14548,9 +17039,9 @@ var args = process.argv.slice(2);
 var cmd2 = args[0] || "";
 var subArgs = args.slice(1);
 var isDetachedChild = process.env.SYNKRO_TELEMETRY_DETACHED === "1";
-var FLUSH_SKIP = /* @__PURE__ */ new Set(["grade", "version", "--version", "-v", "help", "--help", "-h", ""]);
+var FLUSH_SKIP = /* @__PURE__ */ new Set(["grade", "inventory-sync", "version", "--version", "-v", "help", "--help", "-h", ""]);
 function printVersion() {
-  console.log("1.7.95");
+  console.log("1.9.0");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents
@@ -14569,9 +17060,16 @@ Commands:
   claude-desktop         Monitor Claude Desktop conversations (local, macOS)
   telemetry <sub>        Inspect or flush local telemetry events
   whoami                 Show resolved identity + where grading runs
+  workspace <sub>        Answer the task-workspace question (stay/clear/status)
+  ui                     Governed multiplexer: spaces + agents, real sessions in tabs
   refresh                Refresh the login session (keeps you signed in; run on a schedule)
   version                Show version
 
+  workspace:
+    synkro workspace stay <taskId>       keep working in the current checkout
+    synkro workspace clear <taskId>      forget the choice (Synkro asks again)
+    synkro workspace status [taskId]     show recorded choices
+
   config:
     synkro config                        show current settings
     synkro config grading <local|byok>   where grading runs
@@ -14675,6 +17173,16 @@ async function main() {
       await whoamiCommand2(subArgs);
       break;
     }
+    case "workspace": {
+      const { workspaceCommand: workspaceCommand2 } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
+      await workspaceCommand2(subArgs);
+      break;
+    }
+    case "ui": {
+      const { uiCommand: uiCommand2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+      await uiCommand2(subArgs);
+      break;
+    }
     case "refresh": {
       const { refreshCommand: refreshCommand2 } = await Promise.resolve().then(() => (init_refresh(), refresh_exports));
       await refreshCommand2(subArgs);
@@ -14738,6 +17246,13 @@ async function main() {
       await telemetryCommand2(subArgs);
       break;
     }
+    // Internal detached worker. Operational inventory is independent of product
+    // telemetry and always fail-open; it intentionally stays out of help output.
+    case "inventory-sync": {
+      const { syncOperationalInventory: syncOperationalInventory2 } = await Promise.resolve().then(() => (init_sync2(), sync_exports2));
+      await syncOperationalInventory2({ force: subArgs.includes("--detached") || subArgs.includes("--force") });
+      break;
+    }
     default: {
       console.error(`Unknown command: ${cmd2}`);
       printHelp2();
@@ -14752,6 +17267,11 @@ async function postDispatchFlush() {
     flushDetached2();
   } catch {
   }
+  try {
+    const { syncOperationalInventoryDetached: syncOperationalInventoryDetached2 } = await Promise.resolve().then(() => (init_sync2(), sync_exports2));
+    syncOperationalInventoryDetached2();
+  } catch {
+  }
 }
 async function shutdown(code) {
   try {
@@ -14775,7 +17295,7 @@ async function shutdown(code) {
   }, 200);
   force.unref();
 }
-main().then(() => postDispatchFlush()).then(() => shutdown(0)).catch(async (err) => {
+main().then(() => postDispatchFlush()).then(() => shutdown(typeof process.exitCode === "number" ? process.exitCode : 0)).catch(async (err) => {
   try {
     const { emit: emit2 } = await Promise.resolve().then(() => (init_telemetry(), telemetry_exports));
     emit2("error", {