@synkro-sh/cli 1.7.92 → 1.7.93

package/dist/bootstrap.js

@@ -147,7 +147,7 @@ function getIdentity() {
   if (cached2) return cached2;
   let cliVersion = "0.0.0";
   try {
-    cliVersion = "1.7.92";
+    cliVersion = "1.7.93";
   } catch {
   }
   const creds = loadCredentialsIdentity();
@@ -1735,18 +1735,6 @@ function installCCHooks(settingsPath, config) {
     ],
     [SYNKRO_MARKER]: true
   });
-  if (config.promptRouteScriptPath) {
-    settings.hooks.UserPromptSubmit.push({
-      hooks: [
-        {
-          type: "command",
-          command: config.promptRouteScriptPath,
-          timeout: 5
-        }
-      ],
-      [SYNKRO_MARKER]: true
-    });
-  }
   settings.hooks.Stop = settings.hooks.Stop ?? [];
   removeSynkroEntries(settings.hooks, "Stop");
   settings.hooks.Stop.push({
@@ -2112,7 +2100,6 @@ function installCodexHooks(hooksJsonPath, config) {
   if (config.taskActivateIntentScriptPath) push(h, "PermissionRequest", [cmd(config.taskActivateIntentScriptPath, 5)], M_ACTIVATE);
   push(h, "PostToolUse", [cmd(config.bashFollowupScriptPath, 10)], M_BASH);
   push(h, "UserPromptSubmit", [cmd(config.userPromptSubmitScriptPath, 5)]);
-  if (config.promptRouteScriptPath) push(h, "UserPromptSubmit", [cmd(config.promptRouteScriptPath, 5)]);
   push(h, "SessionStart", [cmd(config.sessionStartScriptPath, 5)]);
   push(h, "SubagentStart", [cmd(config.subagentStartScriptPath, 5)]);
   if (!config.skipTranscriptSync) push(h, "SubagentStop", [cmd(config.subagentStopScriptPath, 5)]);
@@ -2141,13 +2128,14 @@ function uninstallCodexHooks(hooksJsonPath) {
   writeHooksFileAtomic2(hooksJsonPath, file);
   return true;
 }
-var SYNKRO_MARKER3, M_BASH, CODEX_EDIT_MATCHER, M_EDIT, M_AGENT, M_MCP, M_ACTIVATE, ALL_EVENTS2;
+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"() {
     "use strict";
     init_platform();
     SYNKRO_MARKER3 = "__synkro_managed__";
-    M_BASH = "Bash";
+    CODEX_BASH_MATCHER = "^(?:Bash|exec_command|functions[._]exec_command)$";
+    M_BASH = CODEX_BASH_MATCHER;
     CODEX_EDIT_MATCHER = "^(?:apply_patch|ApplyPatch|Edit|Write|functions[._]apply_patch)$";
     M_EDIT = CODEX_EDIT_MATCHER;
     M_AGENT = "Agent";
@@ -2157,6 +2145,126 @@ var init_codexHookConfig = __esm({
   }
 });
 
+// cli/installer/codexHookTrust.ts
+import { spawn as spawn2 } from "child_process";
+function parseCodexHookTrustOutput(stdout) {
+  for (const line of stdout.split("\n")) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const data = message?.result?.data;
+    if (!Array.isArray(data)) continue;
+    const hooks = data.flatMap((entry) => Array.isArray(entry?.hooks) ? entry.hooks : []).filter((hook) => typeof hook.command === "string" && isSynkroHookCommand(hook.command));
+    if (!hooks.length) return null;
+    return {
+      total: hooks.length,
+      trusted: hooks.filter((hook) => hook.trustStatus === "trusted" || hook.trustStatus === "managed").length,
+      needsReview: hooks.filter((hook) => hook.trustStatus === "modified" || hook.trustStatus === "untrusted").length,
+      disabled: hooks.filter((hook) => hook.enabled === false).length
+    };
+  }
+  return null;
+}
+function inspectCodexHookTrust(codexBinary = "codex", cwd = process.cwd()) {
+  return new Promise((resolve6) => {
+    let settled = false;
+    let stdout = "";
+    let pending = "";
+    let child;
+    const finish = (summary) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.stdin.end();
+      } catch {
+      }
+      try {
+        child.kill();
+      } catch {
+      }
+      resolve6(summary);
+    };
+    const timer = setTimeout(() => finish(null), 1e4);
+    try {
+      child = spawn2(codexBinary, ["app-server", "--stdio"], {
+        cwd,
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      child.once("error", () => finish(null));
+      child.once("exit", () => finish(parseCodexHookTrustOutput(stdout)));
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        pending += chunk;
+        const lines = pending.split("\n");
+        pending = lines.pop() || "";
+        for (const line of lines) {
+          let message;
+          try {
+            message = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (message?.id === 1 && message?.result) {
+            child.stdin.write(JSON.stringify({
+              id: 2,
+              method: "hooks/list",
+              params: { cwds: [cwd] }
+            }) + "\n");
+          } else if (message?.id === 2) {
+            finish(parseCodexHookTrustOutput(line));
+          }
+        }
+      });
+      child.stdin.write(JSON.stringify({
+        id: 1,
+        method: "initialize",
+        params: {
+          clientInfo: { name: "synkro-cli", version: "1" },
+          capabilities: { experimentalApi: true }
+        }
+      }) + "\n");
+    } catch {
+      finish(null);
+    }
+  });
+}
+function codexHookTrustLines(summary) {
+  if (!summary) {
+    return [
+      "  \u26A0 Codex hook trust could not be verified.",
+      "    Restart Codex, run /hooks, and review the Synkro hooks before relying on enforcement."
+    ];
+  }
+  if (summary.needsReview === 0 && summary.disabled === 0 && summary.trusted === summary.total) {
+    return [`  \u2713 Codex hook trust confirmed (${summary.trusted}/${summary.total} active)`];
+  }
+  const issues = [
+    summary.needsReview > 0 ? `${summary.needsReview} need review` : "",
+    summary.disabled > 0 ? `${summary.disabled} disabled` : ""
+  ].filter(Boolean).join(", ");
+  return [
+    `  \u26A0 Codex security enforcement is not active (${issues}).`,
+    "    Restart Codex, run /hooks, and trust only the Synkro hooks before relying on enforcement."
+  ];
+}
+async function reportCodexHookTrust(codexBinary, cwd) {
+  const summary = await inspectCodexHookTrust(codexBinary || "codex", cwd);
+  for (const line of codexHookTrustLines(summary)) console.log(line);
+  return summary;
+}
+var init_codexHookTrust = __esm({
+  "cli/installer/codexHookTrust.ts"() {
+    "use strict";
+    init_platform();
+  }
+});
+
 // cli/installer/mcpConfig.ts
 import { existsSync as existsSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync9, renameSync as renameSync6, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir12 } from "os";
@@ -2982,6 +3090,26 @@ export function normalizeCodexApplyPatch(payload: any): void {
   } catch { /* leave payload untouched on any parse error */ }
 }
 
+/**
+ * Normalize Codex app/local-function command aliases into the Bash hook shape
+ * consumed by scanRouter. Codex CLI already emits Bash + command; bridges may
+ * retain exec_command (optionally namespaced) + cmd.
+ */
+export function normalizeCodexExecCommand(payload: any): void {
+  const toolName = String(payload?.tool_name || '');
+  if (!/^(?:exec_command|functions[._]exec_command)$/i.test(toolName)) return;
+  const toolInput = payload?.tool_input && typeof payload.tool_input === 'object'
+    ? payload.tool_input
+    : {};
+  payload.tool_name = 'Bash';
+  payload.tool_input = {
+    ...toolInput,
+    command: typeof toolInput.command === 'string'
+      ? toolInput.command
+      : String(toolInput.cmd || ''),
+  };
+}
+
 type RecoveredCodexEdit = { payload: Record<string, any>; baseContent?: string };
 
 function completedCodexToolRecord(entry: any): any {
@@ -3295,9 +3423,12 @@ export async function runStub(surface: string, opts: StubOpts = {}): Promise<voi
     const input = await readStdin();
     if (!input.trim()) { out(failOpen(harness)); return; }
     const payload = JSON.parse(input);
-    // Codex: rewrite apply_patch tool_input into the CC edit shape before any
-    // surface reads it (edit/cwe/cve). No-op for CC/Cursor and non-edit tools.
-    if (harness === 'codex') normalizeCodexApplyPatch(payload);
+    // Codex: rewrite bridged tool aliases into the shared CC shapes before any
+    // surface reads them. No-op for CC/Cursor and already-canonical tools.
+    if (harness === 'codex') {
+      normalizeCodexApplyPatch(payload);
+      normalizeCodexExecCommand(payload);
+    }
     if (harness === 'codex' && opts.subagent) {
       const parentSessionId = String(payload?.session_id || '');
       const childSessionId = String(payload?.agent_id || '');
@@ -3763,165 +3894,8 @@ function emitStubTelemetry(
     STUB_USER_PROMPT_SUBMIT_TS = stubHook("prompt-submit", "{ telemetry: true }");
     STUB_BASH_FOLLOWUP_TS = stubHook("bash-followup", "{ telemetry: true }");
     STUB_PROMPT_ROUTE_TS = `#!/usr/bin/env bun
-import { readFileSync, unlinkSync, mkdirSync, writeFileSync, readdirSync, existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { spawnSync, spawn } from 'node:child_process';
-
-const HOME = homedir();
-const MODEL_RE = /^[A-Za-z0-9._:-]{1,64}$/;
-
-function cliBin(): string {
-  try {
-    const txt = readFileSync(join(HOME, '.synkro', 'config.env'), 'utf-8');
-    for (const line of txt.split('\\n')) {
-      const t = line.trim();
-      if (t.startsWith('SYNKRO_CLI_BIN=')) {
-        let v = t.slice('SYNKRO_CLI_BIN='.length).trim();
-        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
-        return v;
-      }
-    }
-  } catch {}
-  return process.env.SYNKRO_CLI_BIN || '';
-}
-
-function mcpJwt(): string {
-  try { return readFileSync(join(HOME, '.synkro', '.mcp-jwt'), 'utf-8').trim(); } catch { return ''; }
-}
-
-// The caller's own tmux session, from the inherited $TMUX \u2014 so routing targets
-// THIS session, not whichever shim last wrote the shared active-session file.
-function currentTmuxSession(): string {
-  if (!process.env.TMUX) return '';
-  try {
-    const pane = process.env.TMUX_PANE || '';
-    const args = pane
-      ? ['display-message', '-p', '-t', pane, '#{session_name}']
-      : ['display-message', '-p', '#{session_name}'];
-    const r = spawnSync('tmux', args, { encoding: 'utf-8' });
-    if (r.status === 0) return (r.stdout || '').trim();
-  } catch {}
-  return '';
-}
-
-const chunks: Buffer[] = [];
-for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-
-// Verdict: allow ({}) unless we decide to BLOCK this prompt for routing. We must
-// emit exactly one JSON line at the end (not up-front) so the block path can win.
-let blockForRouting = false;
-try {
-  const payload = JSON.parse(Buffer.concat(chunks).toString('utf-8') || '{}');
-  const sid = String(payload.session_id || payload.conversation_id || '');
-  if (sid) {
-    const safeSid = sid.replace(/[^A-Za-z0-9_-]/g, '_');
-    const tmuxSession = currentTmuxSession();
-    const prompt = String(payload.prompt || '');
-
-    // Session registry: record THIS live session (heartbeat \u2014 ts refreshed every
-    // prompt) so a router or a human can enumerate live sessions via
-    // 'synkro sessions' and target exactly one by session_id. Wrapped + best-effort
-    // so it never delays or breaks the prompt.
-    try {
-      const sessDir = join(HOME, '.synkro', 'pty', 'sessions');
-      mkdirSync(sessDir, { recursive: true });
-      const rec = {
-        session_id: sid,
-        tmux_session: tmuxSession,
-        cwd: String(payload.cwd || ''),
-        last_prompt: prompt.slice(0, 200),
-        transcript_path: String(payload.transcript_path || ''),
-        ts: Date.now(),
-      };
-      writeFileSync(join(sessDir, safeSid + '.json'), JSON.stringify(rec));
-      // TTL-prune stale records (24h) \u2014 cheap, no per-record process spawn. Live
-      // sessions refresh their ts every prompt, so only ended ones age out.
-      const TTL = 24 * 60 * 60 * 1000;
-      const now = Date.now();
-      for (const f of readdirSync(sessDir)) {
-        if (!f.endsWith('.json')) continue;
-        try {
-          const r = JSON.parse(readFileSync(join(sessDir, f), 'utf-8'));
-          if (!r || typeof r.ts !== 'number' || now - r.ts > TTL) unlinkSync(join(sessDir, f));
-        } catch { try { unlinkSync(join(sessDir, f)); } catch {} }
-      }
-    } catch {}
-
-    // \u2500\u2500 Routing: block + re-inject \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-    // Loop-guard: a re-injected prompt carries route-guard-<sid>; clear it and
-    // pass straight through (never route the re-injected prompt \u2014 that would loop).
-    const guardFile = join(HOME, '.synkro', 'pty', 'route-guard-' + safeSid);
-    let isReinjected = false;
-    try {
-      if (existsSync(guardFile)) { isReinjected = true; try { unlinkSync(guardFile); } catch {} }
-    } catch {}
-
-    // Only route real task prompts. Skip empty input, slash-commands (/\u2026), bash
-    // lines (!\u2026), and common conversational turns \u2014 those are never something to
-    // pick a coding model for, and blocking them would add a needless pause. The
-    // haiku 'keep' verdict is the backstop for anything this quick list misses.
-    const t = prompt.trim();
-    const norm = t.toLowerCase().replace(/[.!?,;:\\s]+$/, '').trim();
-    const CONVERSATIONAL = new Set([
-      'ok', 'okay', 'k', 'kk', 'yes', 'yep', 'yeah', 'ya', 'y', 'no', 'nope', 'n',
-      'sure', 'thanks', 'thank you', 'thx', 'ty', 'cool', 'nice', 'great', 'awesome',
-      'perfect', 'got it', 'gotcha', 'right', 'makes sense', 'sounds good', 'lgtm',
-      'continue', 'keep going', 'go on', 'go ahead', 'proceed', 'next', 'more',
-      'again', 'retry', 'stop', 'wait', 'hmm', 'hm', 'oh', 'i see', 'done', 'good',
-    ]);
-    const routable = t.length > 0 && !t.startsWith('/') && !t.startsWith('!') && !CONVERSATIONAL.has(norm);
-
-    // Routing is opt-in via a marker file \u2014 either global ('routing-on', every
-    // session) or per-session ('routing-on-<sid>', just this one). Per-session lets
-    // us enable routing for one session (e.g. a test) without touching the others.
-    let routingEnabled = false;
-    try {
-      routingEnabled = existsSync(join(HOME, '.synkro', 'pty', 'routing-on'))
-        || existsSync(join(HOME, '.synkro', 'pty', 'routing-on-' + safeSid));
-    } catch {}
-
-    if (!isReinjected && routable && routingEnabled) {
-      // ESCALATION-ONLY: classify in-place (fast local head, 1s cap). Block +
-      // escalate to Opus ONLY for a confident opus verdict; never downgrade. Any
-      // timeout / non-opus / error \u2192 run on the current model (no block). This
-      // makes the classifier's weakness (under-firing opus) harmless: worst case
-      // is a MISSED escalation = status quo, never a broken output on a weak model.
-      let escalate = false;
-      try {
-        const resp = await fetch('http://127.0.0.1:' + (process.env.SYNKRO_GRADER_HOST_PORT || '18929') + '/submit', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + mcpJwt() },
-          body: JSON.stringify({ role: 'route-classify', payload: t.slice(0, 1000), content: 'x', hedge: false }),
-          signal: AbortSignal.timeout(1000),
-        });
-        if (resp.ok) {
-          const data = await resp.json();
-          if (/<model>\\s*claude-opus-4-8\\s*<\\/model>/i.test(String(data.result || ''))) escalate = true;
-        }
-      } catch {}
-      if (escalate) {
-        try {
-          const bin = cliBin();
-          if (bin) {
-            // Orchestrator applies the pre-decided escalation (skip re-classify).
-            const child = spawn('node', [bin, 'route-and-resubmit', sid, t.slice(0, 1000), tmuxSession || '', 'claude-opus-4-8'], { detached: true, stdio: 'ignore' });
-            child.unref();
-            blockForRouting = true; // hold this prompt; the orchestrator re-submits it on Opus
-          }
-        } catch {}
-      }
-    }
-  }
-} catch {}
-
-// Emit the single verdict line. Block (with a visible reason) when routing is
-// taking over the prompt; otherwise allow. Fail-open: any throw above \u2192 allow.
-if (blockForRouting) {
-  process.stdout.write(JSON.stringify({ decision: 'block', reason: 'Synkro is routing this to the best model and will resubmit it automatically\u2026' }) + '\\n');
-} else {
-  process.stdout.write('{}\\n');
-}
+for await (const _chunk of process.stdin) {}
+process.stdout.write('{}\\n');
 `;
     STUB_TASK_ACTIVATE_INTENT_TS = `#!/usr/bin/env bun
 import { readFileSync } from 'node:fs';
@@ -4560,7 +4534,7 @@ __export(claudeDesktopTap_exports, {
   claudeDesktopInstalled: () => claudeDesktopInstalled,
   runClaudeDesktopTap: () => runClaudeDesktopTap
 });
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { writeFileSync as writeFileSync12, mkdtempSync, mkdirSync as mkdirSync10, readFileSync as readFileSync15, existsSync as existsSync17 } from "fs";
 import { join as join13 } from "path";
 import { homedir as homedir15 } from "os";
@@ -4709,7 +4683,7 @@ async function runClaudeDesktopTap(opts = {}) {
   const runnerPath = join13(sessionDir, "run.sh");
   writeFileSync12(runnerPath, buildRunner(sessionDir), { mode: 493 });
   await new Promise((resolve6) => {
-    const child = spawn2("bash", [runnerPath], {
+    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" : "" }
     });
@@ -6093,6 +6067,7 @@ __export(dockerInstall_exports, {
   dockerUpdate: () => dockerUpdate,
   ensurePgliteProxyCredentials: () => ensurePgliteProxyCredentials,
   imageTag: () => imageTag,
+  isContainerActiveState: () => isContainerActiveState,
   normalizeProvider: () => normalizeProvider,
   poolLabel: () => poolLabel,
   readContainerConfig: () => readContainerConfig,
@@ -6126,6 +6101,9 @@ function resolveContainerName(raw = process.env.SYNKRO_CONTAINER_NAME) {
   }
   return value;
 }
+function isContainerActiveState(status) {
+  return status === "running" || status === "restarting" || status === "paused";
+}
 function createPgliteScramVerifier(password, salt = randomBytes2(16)) {
   const iterations = 4096;
   const saltedPassword = pbkdf2Sync(password, salt, iterations, 32, "sha256");
@@ -6134,27 +6112,29 @@ function createPgliteScramVerifier(password, salt = randomBytes2(16)) {
   const serverKey = createHmac("sha256", saltedPassword).update("Server Key").digest();
   return `SCRAM-SHA-256$${iterations}:${salt.toString("base64")}$${storedKey.toString("base64")}:${serverKey.toString("base64")}`;
 }
-function ensurePgliteProxyCredentials() {
-  const hasPassword = existsSync19(PGLITE_PASSWORD_PATH) && readFileSync17(PGLITE_PASSWORD_PATH, "utf-8").trim().length > 0;
-  const hasUserlist = existsSync19(PGLITE_USERLIST_PATH) && readFileSync17(PGLITE_USERLIST_PATH, "utf-8").trim().length > 0;
+function ensurePgliteProxyCredentials(paths = {}) {
+  const passwordPath = paths.passwordPath ?? PGLITE_PASSWORD_PATH;
+  const userlistPath = paths.userlistPath ?? PGLITE_USERLIST_PATH;
+  const hasPassword = existsSync19(passwordPath) && readFileSync17(passwordPath, "utf-8").trim().length > 0;
+  const hasUserlist = existsSync19(userlistPath) && readFileSync17(userlistPath, "utf-8").trim().length > 0;
   if (hasPassword && hasUserlist) {
-    chmodSync3(PGLITE_PASSWORD_PATH, 384);
-    chmodSync3(PGLITE_USERLIST_PATH, 384);
+    chmodSync3(passwordPath, 384);
+    chmodSync3(userlistPath, 384);
     return;
   }
   const password = randomBytes2(24).toString("base64url");
   const verifier = createPgliteScramVerifier(password);
   const suffix = `${process.pid}.${Date.now()}.tmp`;
-  const passwordTmp = `${PGLITE_PASSWORD_PATH}.${suffix}`;
-  const userlistTmp = `${PGLITE_USERLIST_PATH}.${suffix}`;
+  const passwordTmp = `${passwordPath}.${suffix}`;
+  const userlistTmp = `${userlistPath}.${suffix}`;
   writeFileSync14(passwordTmp, `${password}
 `, { mode: 384 });
   writeFileSync14(userlistTmp, `"synkro" "${verifier}"
 `, { mode: 384 });
-  renameSync7(passwordTmp, PGLITE_PASSWORD_PATH);
-  renameSync7(userlistTmp, PGLITE_USERLIST_PATH);
-  chmodSync3(PGLITE_PASSWORD_PATH, 384);
-  chmodSync3(PGLITE_USERLIST_PATH, 384);
+  renameSync7(passwordTmp, passwordPath);
+  renameSync7(userlistTmp, userlistPath);
+  chmodSync3(passwordPath, 384);
+  chmodSync3(userlistPath, 384);
 }
 function resolveConductorProvider(pool, counts) {
   if (pool !== "auto") return pool;
@@ -6615,7 +6595,7 @@ function dockerStatus() {
     timeout: 5e3
   });
   const status = (r.stdout || "").trim();
-  if (status !== "running") return { running: false };
+  if (!isContainerActiveState(status)) return { running: false };
   return {
     running: true,
     image: imageTag(),
@@ -6785,7 +6765,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.92";
+      if (true) return "1.7.93";
       try {
         const pkg = JSON.parse(readFileSync17(new URL("../../package.json", import.meta.url), "utf8"));
         if (pkg.version) return pkg.version;
@@ -7022,6 +7002,7 @@ __export(ptyShim_exports, {
   injectModel: () => injectModel,
   installPtyShim: () => installPtyShim,
   listSessions: () => listSessions,
+  restoreLegacyClaudeShim: () => restoreLegacyClaudeShim,
   uninstallPtyShim: () => uninstallPtyShim
 });
 import {
@@ -7038,48 +7019,11 @@ import {
 } from "fs";
 import { homedir as homedir20 } from "os";
 import { join as join18 } from "path";
-import { spawnSync as spawnSync5, spawn as spawn3 } from "child_process";
+import { spawnSync as spawnSync5, spawn as spawn4 } from "child_process";
 function rcFiles() {
   const h = homedir20();
   return [join18(h, ".zshrc"), join18(h, ".bashrc"), join18(h, ".bash_profile")];
 }
-function resolveRealClaude() {
-  const r = spawnSync5("bash", ["-lc", `PATH="$(printf '%s' "$PATH" | sed "s#$HOME/.synkro/bin:##g")" command -v claude`], { encoding: "utf-8" });
-  const p = (r.stdout || "").trim();
-  if (p) {
-    try {
-      return realpathSync(p);
-    } catch {
-      return p;
-    }
-  }
-  for (const c of [join18(homedir20(), ".local", "bin", "claude"), "/usr/local/bin/claude", "/opt/homebrew/bin/claude"]) {
-    if (existsSync21(c)) {
-      try {
-        return realpathSync(c);
-      } catch {
-        return c;
-      }
-    }
-  }
-  return "claude";
-}
-function findClaudeLink() {
-  const r = spawnSync5("bash", ["-lc", `PATH="$(printf '%s' "$PATH" | sed "s#$HOME/.synkro/bin:##g")" command -v claude`], { encoding: "utf-8" });
-  let linkPath = (r.stdout || "").trim();
-  if (!linkPath) {
-    const c = join18(homedir20(), ".local", "bin", "claude");
-    if (existsSync21(c)) linkPath = c;
-    else return null;
-  }
-  if (linkPath === SHIM_PATH) return null;
-  let realTarget = linkPath;
-  try {
-    realTarget = realpathSync(linkPath);
-  } catch {
-  }
-  return { linkPath, realTarget };
-}
 function isOurShim(path) {
   try {
     return readFileSync20(path, "utf-8").slice(0, 300).includes("Synkro pty shim");
@@ -7087,44 +7031,39 @@ function isOurShim(path) {
     return false;
   }
 }
-function shadowClaude() {
-  const found = findClaudeLink();
-  if (!found) {
-    console.log("    \xB7 no claude binary to shadow \u2014 PATH shim only");
-    return;
-  }
-  const { linkPath, realTarget } = found;
-  if (isOurShim(linkPath)) {
-    console.log(`    \xB7 ${linkPath.replace(homedir20(), "~")} already shadowed`);
-    return;
-  }
-  let wasSymlink = false;
+function latestVersionedClaude(versionsDir) {
+  let versions = [];
   try {
-    wasSymlink = lstatSync(linkPath).isSymbolicLink();
+    versions = readdirSync3(versionsDir).map((entry) => join18(versionsDir, entry)).filter((entry) => existsSync21(entry)).sort((a, b) => a.localeCompare(b, void 0, { numeric: true, sensitivity: "base" }));
   } catch {
   }
-  const state = { linkPath, realTarget, wasSymlink };
-  try {
-    writeFileSync16(SHADOW_STATE_FILE, JSON.stringify(state), "utf-8");
-  } catch {
-  }
-  try {
-    rmSync2(linkPath, { force: true });
-    writeFileSync16(linkPath, SHIM_SOURCE.replace("__BAKED_CLAUDE__", realTarget), "utf-8");
-    chmodSync4(linkPath, 493);
-    console.log(`    \u2713 shadowed ${linkPath.replace(homedir20(), "~")} \u2192 shim (real: ${realTarget.replace(homedir20(), "~")})`);
-  } catch (e) {
-    console.warn(`    \u26A0 could not shadow ${linkPath}: ${e.message}`);
+  return versions.at(-1) || "";
+}
+function restoreLegacyClaudeShim(linkPath, versionsDir) {
+  if (!isOurShim(linkPath)) return false;
+  const realTarget = latestVersionedClaude(versionsDir);
+  if (!realTarget) {
+    throw new Error(`no Claude version found under ${versionsDir}`);
   }
+  rmSync2(linkPath, { force: true });
+  symlinkSync(realTarget, linkPath);
+  return true;
 }
 function unshadowClaude() {
   let state;
   try {
     state = JSON.parse(readFileSync20(SHADOW_STATE_FILE, "utf-8"));
   } catch {
+  }
+  if (!state?.linkPath) {
+    const legacyLink = join18(homedir20(), ".local", "bin", "claude");
+    const versionsDir = join18(homedir20(), ".local", "share", "claude", "versions");
+    if (restoreLegacyClaudeShim(legacyLink, versionsDir)) {
+      const target = realpathSync(legacyLink);
+      console.log(`\u2713 restored ${legacyLink.replace(homedir20(), "~")} \u2192 ${target.replace(homedir20(), "~")}`);
+    }
     return;
   }
-  if (!state?.linkPath) return;
   try {
     if (existsSync21(state.linkPath) && !isOurShim(state.linkPath)) return;
     rmSync2(state.linkPath, { force: true });
@@ -7134,25 +7073,6 @@ function unshadowClaude() {
     console.warn(`  \u26A0 could not restore claude: ${e.message} \u2014 run: ln -sf ${state.realTarget} ${state.linkPath}`);
   }
 }
-function addPathBlock() {
-  const touched = [];
-  for (const rc of rcFiles()) {
-    if (!existsSync21(rc) && rc.endsWith(".bash_profile")) continue;
-    let body = "";
-    try {
-      body = readFileSync20(rc, "utf-8");
-    } catch {
-    }
-    const cleaned = stripBlock(body);
-    const next = cleaned.replace(/\n*$/, "") + (cleaned ? "\n\n" : "") + RC_BLOCK + "\n";
-    try {
-      writeFileSync16(rc, next, "utf-8");
-      touched.push(rc);
-    } catch {
-    }
-  }
-  return touched;
-}
 function stripBlock(body) {
   if (!body.includes(RC_BEGIN)) return body;
   const re = new RegExp(`\\n?${escapeRe(RC_BEGIN)}[\\s\\S]*?${escapeRe(RC_END)}\\n?`, "g");
@@ -7162,28 +7082,14 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function installPtyShim() {
-  mkdirSync14(SHIM_BIN_DIR, { recursive: true });
-  mkdirSync14(PTY_STATE_DIR, { recursive: true });
-  const real = resolveRealClaude();
-  writeFileSync16(SHIM_PATH, SHIM_SOURCE.replace("__BAKED_CLAUDE__", real), "utf-8");
-  chmodSync4(SHIM_PATH, 493);
-  const touched = addPathBlock();
-  console.log(`  \u2713 pty routing shim installed (real claude: ${real})`);
-  shadowClaude();
-  if (touched.length) console.log(`    added ~/.synkro/bin to PATH in: ${touched.map((t) => t.replace(homedir20(), "~")).join(", ")}`);
+  console.warn("Synkro host model routing has been removed; cleaning up any legacy pty shim.");
+  uninstallPtyShim();
 }
 function uninstallPtyShim() {
   try {
     unshadowClaude();
   } catch {
   }
-  try {
-    const ls = spawnSync5("tmux", ["ls", "-F", "#{session_name}"], { encoding: "utf-8" });
-    for (const s of (ls.stdout || "").split("\n")) {
-      if (s.startsWith(SHIM_SESSION_PREFIX)) spawnSync5("tmux", ["kill-session", "-t", `=${s}`], { encoding: "utf-8" });
-    }
-  } catch {
-  }
   const cleaned = [];
   for (const rc of rcFiles()) {
     if (!existsSync21(rc)) continue;
@@ -7284,7 +7190,7 @@ function injectModel(model, sessionOverride) {
   } catch {
   }
   const poll = `old=$(cat '${pidFile}' 2>/dev/null); if [ -n "$old" ]; then kill "$old" 2>/dev/null; fi; rm -f '${pidFile}'; set -o noclobber; echo $$ > '${pidFile}' 2>/dev/null || exit 1; set +o noclobber; trap 'rm -f "${pidFile}"' EXIT; for i in $(seq 1 40); do if tmux capture-pane -t ${session} -p -S -25 2>/dev/null | grep -qiE 'switch model|yes, switch'; then tmux send-keys -t ${session} -l '1'; sleep 0.1; tmux send-keys -t ${session} Enter; break; fi; sleep 0.1; done`;
-  const child = spawn3("bash", ["-c", poll], { detached: true, stdio: "ignore" });
+  const child = spawn4("bash", ["-c", poll], { detached: true, stdio: "ignore" });
   child.unref();
   return true;
 }
@@ -7570,7 +7476,7 @@ __export(install_exports, {
 import { existsSync as existsSync22, mkdirSync as mkdirSync15, writeFileSync as writeFileSync17, chmodSync as chmodSync5, readFileSync as readFileSync21, readdirSync as readdirSync4, unlinkSync as unlinkSync7, statSync as statSync2 } from "fs";
 import { homedir as homedir21 } from "os";
 import { join as join19, isAbsolute, resolve as resolve4 } from "path";
-import { execSync as execSync4, spawn as spawn4 } from "child_process";
+import { execSync as execSync4, spawn as spawn5 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 import { createHash as createHash4 } from "crypto";
 function resolvePersistedHookMode() {
@@ -7698,7 +7604,6 @@ async function promptTranscriptSources(wantCC, wantCursor, wantCodex) {
 function ensureSynkroDir() {
   mkdirSync15(SYNKRO_DIR11, { recursive: true });
   mkdirSync15(HOOKS_DIR, { recursive: true });
-  mkdirSync15(BIN_DIR, { recursive: true });
   mkdirSync15(OFFSETS_DIR, { recursive: true });
   mkdirSync15(join19(SYNKRO_DIR11, "sessions"), { recursive: true });
 }
@@ -7722,7 +7627,7 @@ function writeHookScripts() {
   const subagentStartScriptPath = join19(HOOKS_DIR, "codex-subagent-start.ts");
   const subagentStopScriptPath = join19(HOOKS_DIR, "codex-subagent-stop.ts");
   const userPromptSubmitScriptPath = join19(HOOKS_DIR, "cc-user-prompt-submit.ts");
-  const promptRouteScriptPath = join19(HOOKS_DIR, "cc-prompt-route.ts");
+  const legacyPromptRouteScriptPath = join19(HOOKS_DIR, "cc-prompt-route.ts");
   const commonScriptPath = join19(HOOKS_DIR, "_synkro-common.ts");
   const commonBashScriptPath = join19(HOOKS_DIR, "_synkro-common.sh");
   const installScanScriptPath = join19(HOOKS_DIR, "cc-install-scan.ts");
@@ -7753,7 +7658,7 @@ function writeHookScripts() {
     [subagentStartScriptPath, STUB_SUBAGENT_START_TS],
     [subagentStopScriptPath, STUB_SUBAGENT_STOP_TS],
     [userPromptSubmitScriptPath, STUB_USER_PROMPT_SUBMIT_TS],
-    [promptRouteScriptPath, STUB_PROMPT_ROUTE_TS],
+    [legacyPromptRouteScriptPath, STUB_PROMPT_ROUTE_TS],
     [installScanScriptPath, STUB_INSTALL_SCAN_TS],
     [taskActivateIntentScriptPath, STUB_TASK_ACTIVATE_INTENT_TS],
     [mcpGateScriptPath, STUB_MCP_GATE_TS],
@@ -7792,7 +7697,6 @@ function writeHookScripts() {
     subagentStartScript: subagentStartScriptPath,
     subagentStopScript: subagentStopScriptPath,
     userPromptSubmitScript: userPromptSubmitScriptPath,
-    promptRouteScript: promptRouteScriptPath,
     installScanScript: installScanScriptPath,
     cursorBashJudgeScript: cursorBashJudgePath,
     cursorEditCaptureScript: cursorEditCapturePath,
@@ -7830,7 +7734,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle2(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle2(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle2(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle2("1.7.92")}`
+    `SYNKRO_VERSION=${shellQuoteSingle2("1.7.93")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle2(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle2(safeUserId)}`);
@@ -8572,7 +8476,7 @@ async function installCommand(opts = {}) {
   await setTelemetryState({ enabled: true, remoteFlushEnabled: telemetryConsent });
   emit("install", {
     phase: "started",
-    cli_version_to: "1.7.92",
+    cli_version_to: "1.7.93",
     agents_detected: agents.map((a) => a.kind),
     with_github: false,
     with_local_cc: false,
@@ -8613,7 +8517,6 @@ async function installCommand(opts = {}) {
         sessionStartScriptPath: scripts.sessionStartScript,
         transcriptSyncScriptPath: scripts.transcriptSyncScript,
         userPromptSubmitScriptPath: scripts.userPromptSubmitScript,
-        promptRouteScriptPath: scripts.promptRouteScript,
         installScanScriptPath: scripts.installScanScript,
         taskActivateIntentScriptPath: scripts.taskActivateIntentScript,
         mcpGateScriptPath: scripts.mcpGateScript,
@@ -8661,25 +8564,22 @@ async function installCommand(opts = {}) {
         subagentStartScriptPath: scripts.subagentStartScript,
         subagentStopScriptPath: scripts.subagentStopScript,
         userPromptSubmitScriptPath: scripts.userPromptSubmitScript,
-        promptRouteScriptPath: scripts.promptRouteScript,
         installScanScriptPath: scripts.installScanScript,
         taskActivateIntentScriptPath: scripts.taskActivateIntentScript,
         mcpGateScriptPath: scripts.mcpGateScript,
         skipTranscriptSync: !transcriptCodex
       });
       console.log(`Configured ${agent.name} hooks at ${agent.settingsPath}`);
-      console.log("  One-time setup: restart Codex, run /hooks, then review and trust the Synkro hooks.");
+      await reportCodexHookTrust(agent.binaryPath, process.cwd());
     }
   }
   console.log();
-  if (hasClaudeCode) {
-    try {
-      installPtyShim();
-    } catch (e) {
-      console.warn(`  \u26A0 pty shim install skipped: ${e.message}`);
-    }
-    console.log();
+  try {
+    uninstallPtyShim();
+  } catch (e) {
+    console.warn(`  \u26A0 legacy pty shim cleanup skipped: ${e.message}`);
   }
+  console.log();
   let userId;
   let orgId;
   let email;
@@ -9093,7 +8993,7 @@ async function installCommand(opts = {}) {
     }
   }
   try {
-    const child = spawn4(process.execPath, [process.argv[1], "reachability-scan", "--quiet"], {
+    const child = spawn5(process.execPath, [process.argv[1], "reachability-scan", "--quiet"], {
       detached: true,
       stdio: "ignore",
       cwd: process.cwd()
@@ -9274,7 +9174,6 @@ function reconcileHarness() {
       sessionStartScriptPath: scripts.sessionStartScript,
       transcriptSyncScriptPath: scripts.transcriptSyncScript,
       userPromptSubmitScriptPath: scripts.userPromptSubmitScript,
-      promptRouteScriptPath: scripts.promptRouteScript,
       installScanScriptPath: scripts.installScanScript,
       taskActivateIntentScriptPath: scripts.taskActivateIntentScript,
       mcpGateScriptPath: scripts.mcpGateScript,
@@ -9344,14 +9243,13 @@ function reconcileHarness() {
       subagentStartScriptPath: scripts.subagentStartScript,
       subagentStopScriptPath: scripts.subagentStopScript,
       userPromptSubmitScriptPath: scripts.userPromptSubmitScript,
-      promptRouteScriptPath: scripts.promptRouteScript,
       installScanScriptPath: scripts.installScanScript,
       taskActivateIntentScriptPath: scripts.taskActivateIntentScript,
       mcpGateScriptPath: scripts.mcpGateScript,
       skipTranscriptSync: !persistedTranscriptConsent("CODEX")
     });
     console.log("  \u2713 Codex hooks registered");
-    console.log("    One-time setup: restart Codex, run /hooks, then review and trust the Synkro hooks.");
+    console.log("    Restart Codex and review /hooks whenever Codex marks a Synkro hook modified.");
     try {
       installCodexMcpConfig({ gatewayUrl: "", bearerToken: "", local: true });
       console.log("  \u2713 Codex MCP registered");
@@ -10119,7 +10017,7 @@ async function syncCodexTranscriptsBulk(gatewayUrl, token, repo) {
   }
   return { sessions: totalSessions, messages: totalMessages };
 }
-var SYNKRO_DIR11, HOOKS_DIR, BIN_DIR, CONFIG_PATH4, MCP_STDIO_PROXY_SRC, OFFSETS_DIR, CLOUD_JWT_PATH, SKILLS_DISCOVERED_PATH;
+var SYNKRO_DIR11, HOOKS_DIR, CONFIG_PATH4, MCP_STDIO_PROXY_SRC, OFFSETS_DIR, CLOUD_JWT_PATH, SKILLS_DISCOVERED_PATH;
 var init_install = __esm({
   "cli/commands/install.ts"() {
     "use strict";
@@ -10127,6 +10025,7 @@ var init_install = __esm({
     init_ccHookConfig();
     init_cursorHookConfig();
     init_codexHookConfig();
+    init_codexHookTrust();
     init_mcpConfig();
     init_synkroCommand();
     init_skillParser();
@@ -10146,7 +10045,6 @@ var init_install = __esm({
     init_codexTranscriptMessages();
     SYNKRO_DIR11 = join19(homedir21(), ".synkro");
     HOOKS_DIR = join19(SYNKRO_DIR11, "hooks");
-    BIN_DIR = join19(SYNKRO_DIR11, "bin");
     CONFIG_PATH4 = join19(SYNKRO_DIR11, "config.env");
     MCP_STDIO_PROXY_SRC = `#!/usr/bin/env bun
 import { readFileSync } from 'node:fs';
@@ -11202,7 +11100,7 @@ var scanPr_exports = {};
 __export(scanPr_exports, {
   scanPrCommand: () => scanPrCommand
 });
-import { execSync as execSync5, spawn as spawn5 } from "child_process";
+import { execSync as execSync5, spawn as spawn6 } from "child_process";
 import { readFileSync as readFileSync24, existsSync as existsSync26 } from "fs";
 import { join as join23 } from "path";
 function parseMatchSpec(condition) {
@@ -11413,7 +11311,7 @@ ${hunks}`;
   const fullPrompt = promptHeader + userMessage;
   return new Promise((resolve6) => {
     const t0 = Date.now();
-    const proc = spawn5(
+    const proc = spawn6(
       "claude",
       ["--print", "--model", "claude-sonnet-4-6", "--output-format", "json", "--no-session-persistence"],
       {
@@ -11512,7 +11410,7 @@ ${JSON.stringify(findings, null, 2)}
 function spawnOpusConsolidator(findings, claudeToken) {
   return new Promise((resolve6) => {
     const prompt = buildConsolidationPrompt(findings);
-    const proc = spawn5(
+    const proc = spawn6(
       "claude",
       ["--print", "--model", "claude-opus-4-7", "--output-format", "json", "--no-session-persistence"],
       {
@@ -11925,296 +11823,20 @@ var init_scanPr = __esm({
   }
 });
 
-// cli/local-cc/routeDecide.ts
-var routeDecide_exports = {};
-__export(routeDecide_exports, {
-  routeDecide: () => routeDecide
-});
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync19 } from "fs";
+// cli/local-cc/pueue.ts
+import { execFileSync as execFileSync4, spawnSync as spawnSync9, spawn as spawn7 } from "child_process";
 import { homedir as homedir25 } from "os";
 import { join as join24 } from "path";
-function safeSid(sid) {
-  return sid.replace(/[^A-Za-z0-9_-]/g, "_");
-}
-function loadMcpJwt() {
-  try {
-    return readFileSync25(join24(SYNKRO_DIR13, ".mcp-jwt"), "utf-8").trim();
-  } catch {
-    return "";
-  }
-}
-async function routeDecide(sessionId) {
-  if (!sessionId) return;
-  const sid = safeSid(sessionId);
-  let prompt = "";
-  try {
-    const rec = JSON.parse(readFileSync25(join24(SESSIONS_DIR2, sid + ".json"), "utf-8"));
-    prompt = String(rec.last_prompt || "").trim();
-  } catch {
-    return;
-  }
-  if (!prompt) return;
-  let model = "";
-  try {
-    const resp = await fetch(`http://127.0.0.1:${GRADER_HOST_PORT}/submit`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: "Bearer " + loadMcpJwt() },
-      body: JSON.stringify({ role: "route-classify", payload: prompt, content: prompt, hedge: false }),
-      // First call may spin up the route lane (a haiku worker boot), so allow headroom.
-      signal: AbortSignal.timeout(12e4)
-    });
-    if (!resp.ok) return;
-    const data = await resp.json();
-    const m = (data.result || "").match(/<model>\s*([A-Za-z0-9._:-]+)\s*<\/model>/i);
-    model = m ? m[1].trim() : "";
-  } catch {
-    return;
-  }
-  if (!model || !VALID_MODELS.has(model)) return;
-  const lastFile = join24(PTY_DIR, "route-last-" + sid);
-  let last = "";
-  try {
-    last = readFileSync25(lastFile, "utf-8").trim();
-  } catch {
-  }
-  if (model === last) return;
-  try {
-    writeFileSync19(lastFile, model);
-  } catch {
-  }
-  try {
-    writeFileSync19(join24(PTY_DIR, "route-" + sid), model);
-  } catch {
-  }
-}
-var SYNKRO_DIR13, PTY_DIR, SESSIONS_DIR2, VALID_MODELS, GRADER_HOST_PORT;
-var init_routeDecide = __esm({
-  "cli/local-cc/routeDecide.ts"() {
-    "use strict";
-    SYNKRO_DIR13 = join24(homedir25(), ".synkro");
-    PTY_DIR = join24(SYNKRO_DIR13, "pty");
-    SESSIONS_DIR2 = join24(PTY_DIR, "sessions");
-    VALID_MODELS = /* @__PURE__ */ new Set(["claude-haiku-4-5", "claude-sonnet-5", "claude-opus-4-8"]);
-    GRADER_HOST_PORT = process.env.SYNKRO_GRADER_HOST_PORT || "18929";
-  }
-});
-
-// cli/local-cc/routeOrchestrate.ts
-var routeOrchestrate_exports = {};
-__export(routeOrchestrate_exports, {
-  routeAndResubmit: () => routeAndResubmit
-});
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync20 } from "fs";
-import { homedir as homedir26 } from "os";
-import { join as join25 } from "path";
-import { spawnSync as spawnSync9 } from "child_process";
-function safeSid2(sid) {
-  return sid.replace(/[^A-Za-z0-9_-]/g, "_");
-}
-function safeSession(s) {
-  return /^[A-Za-z0-9._:-]{1,64}$/.test(s);
-}
-function loadMcpJwt2() {
-  try {
-    return readFileSync26(join25(SYNKRO_DIR14, ".mcp-jwt"), "utf-8").trim();
-  } catch {
-    return "";
-  }
-}
-async function classifyTask(prompt) {
-  try {
-    const resp = await fetch(`http://127.0.0.1:${GRADER_HOST_PORT2}/submit`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: "Bearer " + loadMcpJwt2() },
-      body: JSON.stringify({ role: "route-classify", payload: prompt, content: prompt, hedge: false }),
-      signal: AbortSignal.timeout(6e4)
-    });
-    if (!resp.ok) return null;
-    const data = await resp.json();
-    const m = (data.result || "").match(/<model>\s*([A-Za-z0-9._:-]+)\s*<\/model>/i);
-    if (!m) return null;
-    const v = m[1].trim();
-    if (v.toLowerCase() === "keep") return "keep";
-    return VALID_MODELS2.has(v) ? v : null;
-  } catch {
-    return null;
-  }
-}
-function lastRoutedModel(sid) {
-  try {
-    const v = readFileSync26(join25(PTY_DIR2, "route-last-" + sid), "utf-8").trim();
-    return VALID_MODELS2.has(v) ? v : "";
-  } catch {
-    return "";
-  }
-}
-function resolveSession(sid, tmuxSession) {
-  const candidates = [];
-  if (tmuxSession) candidates.push(tmuxSession);
-  try {
-    const rec = JSON.parse(readFileSync26(join25(SESSIONS_DIR3, safeSid2(sid) + ".json"), "utf-8"));
-    if (rec.tmux_session) candidates.push(rec.tmux_session);
-  } catch {
-  }
-  try {
-    candidates.push(readFileSync26(ACTIVE_SESSION_FILE2, "utf-8").trim());
-  } catch {
-  }
-  for (const c of candidates) if (c && safeSession(c)) return c;
-  return "";
-}
-async function routeAndResubmit(sessionId, task, tmuxSession, forceModel) {
-  const trimmed = (task || "").trim();
-  if (!sessionId || !trimmed) return;
-  const sid = safeSid2(sessionId);
-  const session = resolveSession(sid, tmuxSession);
-  if (!session) return;
-  if (spawnSync9("tmux", ["has-session", "-t", `=${session}`], { encoding: "utf-8" }).status !== 0) return;
-  const current = lastRoutedModel(sid);
-  const picked = forceModel && VALID_MODELS2.has(forceModel) ? forceModel : await classifyTask(trimmed);
-  const doSwap = !!picked && picked !== "keep" && picked !== current;
-  const sk = (...a) => spawnSync9("tmux", ["send-keys", "-t", session, ...a], { encoding: "utf-8" });
-  const capture = () => spawnSync9("tmux", ["capture-pane", "-t", session, "-p", "-S", "-25"], { encoding: "utf-8" }).stdout || "";
-  await wait(400);
-  if (doSwap) {
-    sk("C-u");
-    await wait(80);
-    sk("-l", `/model ${picked}`);
-    sk("Enter");
-    for (let i = 0; i < 50; i++) {
-      await wait(100);
-      if (/switch model|yes, switch/i.test(capture())) {
-        sk("-l", "1");
-        await wait(120);
-        sk("Enter");
-        break;
-      }
-    }
-    await wait(500);
-    try {
-      writeFileSync20(join25(PTY_DIR2, "route-last-" + sid), picked);
-    } catch {
-    }
-  }
-  try {
-    writeFileSync20(join25(PTY_DIR2, "route-guard-" + sid), "1");
-  } catch {
-  }
-  sk("C-u");
-  await wait(80);
-  spawnSync9("tmux", ["set-buffer", "-b", "synkro-route", trimmed], { encoding: "utf-8" });
-  spawnSync9("tmux", ["paste-buffer", "-t", session, "-b", "synkro-route", "-d"], { encoding: "utf-8" });
-  await wait(120);
-  sk("Enter");
-}
-var SYNKRO_DIR14, PTY_DIR2, SESSIONS_DIR3, ACTIVE_SESSION_FILE2, VALID_MODELS2, GRADER_HOST_PORT2, wait;
-var init_routeOrchestrate = __esm({
-  "cli/local-cc/routeOrchestrate.ts"() {
-    "use strict";
-    SYNKRO_DIR14 = join25(homedir26(), ".synkro");
-    PTY_DIR2 = join25(SYNKRO_DIR14, "pty");
-    SESSIONS_DIR3 = join25(PTY_DIR2, "sessions");
-    ACTIVE_SESSION_FILE2 = join25(PTY_DIR2, "active");
-    VALID_MODELS2 = /* @__PURE__ */ new Set(["claude-haiku-4-5", "claude-sonnet-5", "claude-opus-4-8"]);
-    GRADER_HOST_PORT2 = process.env.SYNKRO_GRADER_HOST_PORT || "18929";
-    wait = (ms) => new Promise((r) => setTimeout(r, ms));
-  }
-});
-
-// cli/local-cc/routingToggle.ts
-var routingToggle_exports = {};
-__export(routingToggle_exports, {
-  routingCommand: () => routingCommand
-});
-import { writeFileSync as writeFileSync21, unlinkSync as unlinkSync9, existsSync as existsSync27, readdirSync as readdirSync6 } from "fs";
-import { homedir as homedir27 } from "os";
-import { join as join26 } from "path";
-function safeSid3(sid) {
-  return sid.replace(/[^A-Za-z0-9_-]/g, "_");
-}
-function markerFor(session) {
-  return session ? join26(PTY_DIR3, "routing-on-" + safeSid3(session)) : join26(PTY_DIR3, "routing-on");
-}
-function routingCommand(args2) {
-  const sub = (args2[0] || "status").trim();
-  let session;
-  const si = args2.indexOf("--session");
-  if (si >= 0 && args2[si + 1]) session = args2[si + 1].trim();
-  if (sub === "on") {
-    try {
-      writeFileSync21(markerFor(session), "1");
-    } catch (e) {
-      console.error("routing on failed:", String(e));
-      return;
-    }
-    console.log(session ? `Routing ON for session ${session}.` : "Routing ON (all sessions).");
-    console.log("  New task prompts will be classified and run on the best model automatically.");
-    return;
-  }
-  if (sub === "off") {
-    let removed = 0;
-    if (session) {
-      if (existsSync27(markerFor(session))) {
-        try {
-          unlinkSync9(markerFor(session));
-          removed++;
-        } catch {
-        }
-      }
-    } else {
-      for (const f of safeList()) {
-        if (f === "routing-on" || f.startsWith("routing-on-")) {
-          try {
-            unlinkSync9(join26(PTY_DIR3, f));
-            removed++;
-          } catch {
-          }
-        }
-      }
-    }
-    console.log(`Routing OFF${session ? ` for session ${session}` : ""} (${removed} marker${removed === 1 ? "" : "s"} cleared).`);
-    return;
-  }
-  const markers = safeList().filter((f) => f === "routing-on" || f.startsWith("routing-on-"));
-  if (markers.length === 0) {
-    console.log("Routing is OFF (no markers).");
-    return;
-  }
-  console.log("Routing is ON:");
-  for (const m of markers) {
-    if (m === "routing-on") console.log("  \u2022 global (all sessions)");
-    else console.log("  \u2022 session " + m.slice("routing-on-".length));
-  }
-}
-function safeList() {
-  try {
-    return readdirSync6(PTY_DIR3);
-  } catch {
-    return [];
-  }
-}
-var PTY_DIR3;
-var init_routingToggle = __esm({
-  "cli/local-cc/routingToggle.ts"() {
-    "use strict";
-    PTY_DIR3 = join26(homedir27(), ".synkro", "pty");
-  }
-});
-
-// cli/local-cc/pueue.ts
-import { execFileSync as execFileSync4, spawnSync as spawnSync10, spawn as spawn6 } from "child_process";
-import { homedir as homedir28 } from "os";
-import { join as join27 } from "path";
 import { connect as connect2 } from "net";
 function pueueAvailable() {
-  const r = spawnSync10("pueue", ["--version"], { encoding: "utf-8" });
+  const r = spawnSync9("pueue", ["--version"], { encoding: "utf-8" });
   if (r.status !== 0) {
     throw new PueueError("pueue CLI not found on PATH. Install pueue (https://github.com/Nukesor/pueue) and start `pueued`.");
   }
 }
 function statusJson() {
   pueueAvailable();
-  const r = spawnSync10("pueue", ["status", "--json"], { encoding: "utf-8" });
+  const r = spawnSync9("pueue", ["status", "--json"], { encoding: "utf-8" });
   if (r.status !== 0) {
     throw new PueueError(`pueue status failed: ${r.stderr || r.stdout || "unknown error"} \u2014 is pueued running?`);
   }
@@ -12259,18 +11881,18 @@ function startTask(opts = {}) {
   let existing = findTask(ch);
   while (existing) {
     if (existing.status === "Running" || existing.status === "Queued") {
-      spawnSync10("tmux", ["kill-session", "-t", `=${ch.tmuxSession}`], { encoding: "utf-8" });
-      spawnSync10("pueue", ["kill", String(existing.id)], { encoding: "utf-8" });
+      spawnSync9("tmux", ["kill-session", "-t", `=${ch.tmuxSession}`], { encoding: "utf-8" });
+      spawnSync9("pueue", ["kill", String(existing.id)], { encoding: "utf-8" });
       for (let i = 0; i < 10; i++) {
         const check = findTask(ch);
         if (!check || check.id !== existing.id || check.status !== "Running" && check.status !== "Queued") break;
-        spawnSync10("sleep", ["0.5"], { encoding: "utf-8" });
+        spawnSync9("sleep", ["0.5"], { encoding: "utf-8" });
       }
     }
-    spawnSync10("pueue", ["remove", String(existing.id)], { encoding: "utf-8" });
+    spawnSync9("pueue", ["remove", String(existing.id)], { encoding: "utf-8" });
     existing = findTask(ch);
   }
-  const runScript = join27(cwd, "run-claude.sh");
+  const runScript = join24(cwd, "run-claude.sh");
   const args2 = [
     "add",
     "--label",
@@ -12281,7 +11903,7 @@ function startTask(opts = {}) {
     "bash",
     runScript
   ];
-  const r = spawnSync10("pueue", args2, { encoding: "utf-8" });
+  const r = spawnSync9("pueue", args2, { encoding: "utf-8" });
   if (r.status !== 0) {
     throw new PueueError(`pueue add failed: ${r.stderr || r.stdout}`);
   }
@@ -12292,25 +11914,25 @@ function startTask(opts = {}) {
   return created;
 }
 function stopTask(channel = CHANNEL_PRIMARY) {
-  spawnSync10("tmux", ["kill-session", "-t", `=${channel.tmuxSession}`], { encoding: "utf-8" });
+  spawnSync9("tmux", ["kill-session", "-t", `=${channel.tmuxSession}`], { encoding: "utf-8" });
   let t = findTask(channel);
   while (t) {
     if (t.status === "Running" || t.status === "Queued") {
-      spawnSync10("pueue", ["kill", String(t.id)], { encoding: "utf-8" });
+      spawnSync9("pueue", ["kill", String(t.id)], { encoding: "utf-8" });
       for (let i = 0; i < 10; i++) {
         const check = findTask(channel);
         if (!check || check.id !== t.id || check.status !== "Running" && check.status !== "Queued") break;
-        spawnSync10("sleep", ["0.5"], { encoding: "utf-8" });
+        spawnSync9("sleep", ["0.5"], { encoding: "utf-8" });
       }
     }
-    spawnSync10("pueue", ["remove", String(t.id)], { encoding: "utf-8" });
+    spawnSync9("pueue", ["remove", String(t.id)], { encoding: "utf-8" });
     t = findTask(channel);
   }
 }
 function tailLogs(lines = 80, channel = CHANNEL_PRIMARY) {
   const t = findTask(channel);
   if (!t) return `(no ${channel.taskLabel} task)`;
-  const r = spawnSync10("pueue", ["log", "--lines", String(lines), String(t.id)], { encoding: "utf-8" });
+  const r = spawnSync9("pueue", ["log", "--lines", String(lines), String(t.id)], { encoding: "utf-8" });
   return r.stdout || r.stderr || "(no output)";
 }
 function ensureRunning(opts = {}) {
@@ -12335,8 +11957,8 @@ function probePort(host, port, timeoutMs = 500) {
   });
 }
 function tmuxDismissPrompts(tmuxSession = TMUX_SESSION) {
-  spawnSync10("tmux", ["send-keys", "-t", tmuxSession, "1"], { encoding: "utf-8" });
-  spawnSync10("tmux", ["send-keys", "-t", tmuxSession, "Enter"], { encoding: "utf-8" });
+  spawnSync9("tmux", ["send-keys", "-t", tmuxSession, "1"], { encoding: "utf-8" });
+  spawnSync9("tmux", ["send-keys", "-t", tmuxSession, "Enter"], { encoding: "utf-8" });
 }
 async function waitForChannelReady(port, timeoutMs = 6e4, host = "127.0.0.1", tmuxSession = TMUX_SESSION) {
   const deadline = Date.now() + timeoutMs;
@@ -12348,46 +11970,46 @@ async function waitForChannelReady(port, timeoutMs = 6e4, host = "127.0.0.1", tm
   return probePort(host, port);
 }
 function brewInstall(pkg) {
-  const brew = spawnSync10("brew", ["--version"], { encoding: "utf-8" });
+  const brew = spawnSync9("brew", ["--version"], { encoding: "utf-8" });
   if (brew.status !== 0) return false;
   console.log(`  Installing ${pkg} via brew...`);
-  const r = spawnSync10("brew", ["install", pkg], { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
+  const r = spawnSync9("brew", ["install", pkg], { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
   return r.status === 0;
 }
 function assertPueueInstalled() {
-  let r = spawnSync10("pueue", ["--version"], { encoding: "utf-8" });
+  let r = spawnSync9("pueue", ["--version"], { encoding: "utf-8" });
   if (r.status !== 0) {
     if (process.platform === "darwin" && brewInstall("pueue")) {
-      r = spawnSync10("pueue", ["--version"], { encoding: "utf-8" });
+      r = spawnSync9("pueue", ["--version"], { encoding: "utf-8" });
       if (r.status !== 0) throw new PueueError("pueue install succeeded but binary not found on PATH.");
     } else {
       throw new PueueError("pueue not found. Install it: brew install pueue (macOS) or https://github.com/Nukesor/pueue");
     }
   }
-  const status = spawnSync10("pueue", ["status", "--json"], { encoding: "utf-8", timeout: 5e3 });
+  const status = spawnSync9("pueue", ["status", "--json"], { encoding: "utf-8", timeout: 5e3 });
   if (status.status !== 0) {
     console.log("  Starting pueued daemon...");
-    const child = spawn6("pueued", ["-d"], { stdio: "ignore", detached: true });
+    const child = spawn7("pueued", ["-d"], { stdio: "ignore", detached: true });
     child.unref();
-    spawnSync10("sleep", ["1"]);
-    const retry = spawnSync10("pueue", ["status", "--json"], { encoding: "utf-8", timeout: 5e3 });
+    spawnSync9("sleep", ["1"]);
+    const retry = spawnSync9("pueue", ["status", "--json"], { encoding: "utf-8", timeout: 5e3 });
     if (retry.status !== 0) {
       throw new PueueError("pueue daemon not reachable after starting pueued. Check `pueued` manually.");
     }
   }
-  spawnSync10("pueue", ["parallel", "2"], { encoding: "utf-8" });
+  spawnSync9("pueue", ["parallel", "2"], { encoding: "utf-8" });
 }
 function assertClaudeInstalled() {
-  const r = spawnSync10("claude", ["--version"], { encoding: "utf-8" });
+  const r = spawnSync9("claude", ["--version"], { encoding: "utf-8" });
   if (r.status !== 0) {
     throw new PueueError("claude CLI not found on PATH. Install Claude Code first: https://docs.claude.com/claude-code");
   }
 }
 function assertTmuxInstalled() {
-  let r = spawnSync10("tmux", ["-V"], { encoding: "utf-8" });
+  let r = spawnSync9("tmux", ["-V"], { encoding: "utf-8" });
   if (r.status !== 0) {
     if (process.platform === "darwin" && brewInstall("tmux")) {
-      r = spawnSync10("tmux", ["-V"], { encoding: "utf-8" });
+      r = spawnSync9("tmux", ["-V"], { encoding: "utf-8" });
       if (r.status !== 0) throw new PueueError("tmux install succeeded but binary not found on PATH.");
     } else {
       throw new PueueError("tmux not found. Install it: brew install tmux (macOS) or apt install tmux (Linux)");
@@ -12400,12 +12022,12 @@ var init_pueue = __esm({
     "use strict";
     TASK_LABEL = "synkro-local-cc";
     TMUX_SESSION = "synkro-local-cc";
-    SESSION_DIR2 = join27(homedir28(), ".synkro", "cc_sessions");
+    SESSION_DIR2 = join24(homedir25(), ".synkro", "cc_sessions");
     TASK_LABEL_2 = "synkro-local-cc-2";
     TMUX_SESSION_2 = "synkro-local-cc-2";
-    SESSION_DIR_22 = join27(homedir28(), ".synkro", "cc_sessions_2");
-    SESSION_DIR_32 = join27(homedir28(), ".synkro", "cc_sessions_3");
-    SESSION_DIR_42 = join27(homedir28(), ".synkro", "cc_sessions_4");
+    SESSION_DIR_22 = join24(homedir25(), ".synkro", "cc_sessions_2");
+    SESSION_DIR_32 = join24(homedir25(), ".synkro", "cc_sessions_3");
+    SESSION_DIR_42 = join24(homedir25(), ".synkro", "cc_sessions_4");
     PueueError = class extends Error {
       constructor(message, cause) {
         super(message);
@@ -12420,13 +12042,13 @@ var init_pueue = __esm({
 });
 
 // cli/local-cc/settings.ts
-import { existsSync as existsSync28, readFileSync as readFileSync27 } from "fs";
-import { homedir as homedir29 } from "os";
-import { join as join28 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync25 } from "fs";
+import { homedir as homedir26 } from "os";
+import { join as join25 } from "path";
 function isLocalCCEnabled() {
-  if (!existsSync28(CONFIG_PATH5)) return false;
+  if (!existsSync27(CONFIG_PATH5)) return false;
   try {
-    const content = readFileSync27(CONFIG_PATH5, "utf-8");
+    const content = readFileSync25(CONFIG_PATH5, "utf-8");
     const match = content.match(/^SYNKRO_LOCAL_INFERENCE='([^']*)'/m);
     return match?.[1] === "yes";
   } catch {
@@ -12437,7 +12059,7 @@ var CONFIG_PATH5;
 var init_settings = __esm({
   "cli/local-cc/settings.ts"() {
     "use strict";
-    CONFIG_PATH5 = join28(homedir29(), ".synkro", "config.env");
+    CONFIG_PATH5 = join25(homedir26(), ".synkro", "config.env");
   }
 });
 
@@ -12446,11 +12068,11 @@ var localCc_exports = {};
 __export(localCc_exports, {
   localCcCommand: () => localCcCommand
 });
-import { spawnSync as spawnSync11 } from "child_process";
-import { homedir as homedir30 } from "os";
-import { join as join29 } from "path";
+import { spawnSync as spawnSync10 } from "child_process";
+import { homedir as homedir27 } from "os";
+import { join as join26 } from "path";
 import { readFileSync as fsReadFileSync, existsSync as fsExistsSync } from "fs";
-import { existsSync as existsSync29, readFileSync as readFileSync28, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync26, writeFileSync as writeFileSync19 } from "fs";
 function deploymentMode() {
   const env = (process.env.SYNKRO_DEPLOYMENT_MODE || "").toLowerCase();
   if (env === "docker") return "docker";
@@ -12556,15 +12178,15 @@ TROUBLESHOOTING
 `);
 }
 function readGatewayUrl() {
-  if (existsSync29(CONFIG_PATH6)) {
-    const m = readFileSync28(CONFIG_PATH6, "utf-8").match(/^SYNKRO_GATEWAY_URL='([^']*)'/m);
+  if (existsSync28(CONFIG_PATH6)) {
+    const m = readFileSync26(CONFIG_PATH6, "utf-8").match(/^SYNKRO_GATEWAY_URL='([^']*)'/m);
     if (m) return m[1];
   }
   return "https://api.synkro.sh";
 }
 function updateLocalInferenceFlag(enabled) {
-  if (!existsSync29(CONFIG_PATH6)) return;
-  let content = readFileSync28(CONFIG_PATH6, "utf-8");
+  if (!existsSync28(CONFIG_PATH6)) return;
+  let content = readFileSync26(CONFIG_PATH6, "utf-8");
   const flag = enabled ? "yes" : "no";
   if (content.includes("SYNKRO_LOCAL_INFERENCE=")) {
     content = content.replace(/^SYNKRO_LOCAL_INFERENCE='[^']*'/m, `SYNKRO_LOCAL_INFERENCE='${flag}'`);
@@ -12573,7 +12195,7 @@ function updateLocalInferenceFlag(enabled) {
 SYNKRO_LOCAL_INFERENCE='${flag}'
 `;
   }
-  writeFileSync22(CONFIG_PATH6, content, "utf-8");
+  writeFileSync19(CONFIG_PATH6, content, "utf-8");
 }
 async function setServerGradingProvider(provider) {
   await ensureValidToken();
@@ -12627,7 +12249,7 @@ async function cmdStatus() {
   }
   const ch1Up = await isChannelAvailable();
   console.log(`Channel 1 ${CHANNEL_HOST}:${CHANNEL_PORT}: ${ch1Up ? "reachable" : "unreachable"}`);
-  const tmux1 = spawnSync11("tmux", ["has-session", "-t", `=${TMUX_SESSION_NAME}`], { encoding: "utf-8" });
+  const tmux1 = spawnSync10("tmux", ["has-session", "-t", `=${TMUX_SESSION_NAME}`], { encoding: "utf-8" });
   console.log(`tmux '${TMUX_SESSION_NAME}': ${tmux1.status === 0 ? "live" : "absent"}`);
   const t2 = findTask(CHANNEL_SECONDARY);
   if (!t2) {
@@ -12637,7 +12259,7 @@ async function cmdStatus() {
   }
   const ch2Up = await isChannelAvailable(CHANNEL_2_PORT);
   console.log(`Channel 2 ${CHANNEL_HOST}:${CHANNEL_2_PORT}: ${ch2Up ? "reachable" : "unreachable"}`);
-  const tmux2 = spawnSync11("tmux", ["has-session", "-t", `=${TMUX_SESSION_NAME_2}`], { encoding: "utf-8" });
+  const tmux2 = spawnSync10("tmux", ["has-session", "-t", `=${TMUX_SESSION_NAME_2}`], { encoding: "utf-8" });
   console.log(`tmux '${TMUX_SESSION_NAME_2}': ${tmux2.status === 0 ? "live" : "absent"}`);
 }
 async function cmdEnable() {
@@ -12845,7 +12467,7 @@ function cmdLogs(rest) {
       }
       return "200";
     })();
-    spawnSync11("docker", ["logs", "--tail", tailArg, ...followFlag, "synkro-server"], { stdio: "inherit" });
+    spawnSync10("docker", ["logs", "--tail", tailArg, ...followFlag, "synkro-server"], { stdio: "inherit" });
     return;
   }
   for (const arg of rest) {
@@ -12893,7 +12515,7 @@ function cmdLogs(rest) {
 function cmdAttach(rest) {
   assertTmuxInstalled();
   const readonly = rest.some((a) => a === "--readonly" || a === "-r");
-  const has = spawnSync11("tmux", ["has-session", "-t", `=${TMUX_SESSION_NAME}`], { encoding: "utf-8" });
+  const has = spawnSync10("tmux", ["has-session", "-t", `=${TMUX_SESSION_NAME}`], { encoding: "utf-8" });
   if (has.status !== 0) {
     console.error(`No tmux session '${TMUX_SESSION_NAME}' running. Start it with: synkro local-cc start`);
     process.exit(1);
@@ -12906,7 +12528,7 @@ function cmdAttach(rest) {
   console.log("Detach with Ctrl-B then D. (Do not press Ctrl-C \u2014 that would interrupt claude.)");
   console.log();
   const args2 = readonly ? ["attach-session", "-r", "-t", TMUX_SESSION_NAME] : ["attach-session", "-t", TMUX_SESSION_NAME];
-  const r = spawnSync11("tmux", args2, { stdio: "inherit" });
+  const r = spawnSync10("tmux", args2, { stdio: "inherit" });
   process.exit(r.status ?? 0);
 }
 async function cmdTest() {
@@ -13007,8 +12629,8 @@ var init_localCc = __esm({
     init_install();
     init_client2();
     init_stub();
-    SYNKRO_CONFIG_PATH = join29(homedir30(), ".synkro", "config.env");
-    CONFIG_PATH6 = join29(homedir30(), ".synkro", "config.env");
+    SYNKRO_CONFIG_PATH = join26(homedir27(), ".synkro", "config.env");
+    CONFIG_PATH6 = join26(homedir27(), ".synkro", "config.env");
   }
 });
 
@@ -13017,14 +12639,14 @@ var import_exports = {};
 __export(import_exports, {
   importCommand: () => importCommand
 });
-import { existsSync as existsSync30, readFileSync as readFileSync29, readdirSync as readdirSync7 } from "fs";
-import { homedir as homedir31 } from "os";
-import { join as join30 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync27, readdirSync as readdirSync6 } from "fs";
+import { homedir as homedir28 } from "os";
+import { join as join27 } from "path";
 import { execSync as execSync6 } from "child_process";
 import { createInterface as createInterface4 } from "readline";
 function readMcpJwt() {
   try {
-    return readFileSync29(join30(homedir31(), ".synkro", ".mcp-jwt"), "utf-8").trim();
+    return readFileSync27(join27(homedir28(), ".synkro", ".mcp-jwt"), "utf-8").trim();
   } catch {
     return "";
   }
@@ -13032,7 +12654,7 @@ function readMcpJwt() {
 function readConfigEnv2() {
   const out = {};
   try {
-    for (const line of readFileSync29(CONFIG_PATH7, "utf-8").split("\n")) {
+    for (const line of readFileSync27(CONFIG_PATH7, "utf-8").split("\n")) {
       const t = line.trim();
       if (!t || t.startsWith("#")) continue;
       const eq = t.indexOf("=");
@@ -13044,8 +12666,8 @@ function readConfigEnv2() {
 }
 function projectsFolder() {
   const sanitized = process.cwd().replace(/\//g, "-");
-  const dir = join30(homedir31(), ".claude", "projects", sanitized);
-  return existsSync30(dir) ? dir : null;
+  const dir = join27(homedir28(), ".claude", "projects", sanitized);
+  return existsSync29(dir) ? dir : null;
 }
 function repoName() {
   try {
@@ -13084,7 +12706,7 @@ function extractToolResultText(content, e) {
   return t;
 }
 function parseSession(filePath, sessionId) {
-  const lines = readFileSync29(filePath, "utf-8").split("\n").filter(Boolean);
+  const lines = readFileSync27(filePath, "utf-8").split("\n").filter(Boolean);
   const messages = [];
   const actions = [];
   let step = 0;
@@ -13151,7 +12773,7 @@ async function importCommand() {
     console.log("No Claude Code transcripts found for this repo (~/.claude/projects).");
     return;
   }
-  const files = readdirSync7(dir).filter((f) => f.endsWith(".jsonl"));
+  const files = readdirSync6(dir).filter((f) => f.endsWith(".jsonl"));
   if (!files.length) {
     console.log("No sessions to import.");
     return;
@@ -13164,7 +12786,7 @@ async function importCommand() {
       return;
     }
   }
-  const sessions = files.map((f) => parseSession(join30(dir, f), f.replace(".jsonl", ""))).filter((s) => s.messages.length > 0);
+  const sessions = files.map((f) => parseSession(join27(dir, f), f.replace(".jsonl", ""))).filter((s) => s.messages.length > 0);
   const totalMsgs = sessions.reduce((n, s) => n + s.messages.length, 0);
   let ok = 0, fail = 0;
   if (isCloud) {
@@ -13239,7 +12861,7 @@ var init_import = __esm({
   "cli/commands/import.ts"() {
     "use strict";
     init_stub();
-    CONFIG_PATH7 = join30(homedir31(), ".synkro", "config.env");
+    CONFIG_PATH7 = join27(homedir28(), ".synkro", "config.env");
   }
 });
 
@@ -13281,10 +12903,10 @@ var init_packVerify = __esm({
 });
 
 // cli/installer/lockfile.ts
-import { existsSync as existsSync31, readFileSync as readFileSync30, writeFileSync as writeFileSync23 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync28, writeFileSync as writeFileSync20 } from "fs";
+import { join as join28 } from "path";
 function lockPath(repoRoot2) {
-  return join31(repoRoot2, LOCK_FILE);
+  return join28(repoRoot2, LOCK_FILE);
 }
 function writeLockfile(repoRoot2, entries) {
   const sorted = [...entries].sort((a, b) => a.ref.localeCompare(b.ref));
@@ -13302,7 +12924,7 @@ function writeLockfile(repoRoot2, entries) {
       ""
     ])
   ].join("\n");
-  writeFileSync23(lockPath(repoRoot2), body, "utf-8");
+  writeFileSync20(lockPath(repoRoot2), body, "utf-8");
 }
 var LOCK_FILE;
 var init_lockfile = __esm({
@@ -13317,9 +12939,9 @@ var sync_exports = {};
 __export(sync_exports, {
   syncCommand: () => syncCommand
 });
-import { existsSync as existsSync32, mkdirSync as mkdirSync18, readdirSync as readdirSync8, rmSync as rmSync4, writeFileSync as writeFileSync24 } from "fs";
-import { homedir as homedir32 } from "os";
-import { join as join32 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync18, readdirSync as readdirSync7, rmSync as rmSync4, writeFileSync as writeFileSync21 } from "fs";
+import { homedir as homedir29 } from "os";
+import { join as join29 } from "path";
 function cacheKey(ref, version) {
   return ref.replace(/\//g, "__").replace(/[^\w.@-]/g, "_") + "@" + version + ".json";
 }
@@ -13350,7 +12972,7 @@ async function syncCommand(_args = []) {
   }
   const gateway = (process.env.SYNKRO_GATEWAY_URL || "https://api.synkro.sh").replace(/\/$/, "");
   const cloud = process.env.SYNKRO_DEPLOY_LOCATION === "cloud";
-  const cacheDir = join32(homedir32(), ".synkro", "cache", "packs");
+  const cacheDir = join29(homedir29(), ".synkro", "cache", "packs");
   if (!cloud) mkdirSync18(cacheDir, { recursive: true });
   console.log(`Syncing ${refs.length} standard(s) from the registry\u2026`);
   const lock = [];
@@ -13379,7 +13001,7 @@ async function syncCommand(_args = []) {
     if (!cloud) {
       const fname = cacheKey(ref, data.version);
       keptCacheFiles.add(fname);
-      writeFileSync24(join32(cacheDir, fname), JSON.stringify({
+      writeFileSync21(join29(cacheDir, fname), JSON.stringify({
         ref,
         version: data.version,
         digest: data.digest,
@@ -13391,11 +13013,11 @@ async function syncCommand(_args = []) {
     const ruleCount = Array.isArray(pack.rules) ? pack.rules.length : 0;
     console.log(`  \u2713 ${ref}:${data.version} \u2014 verified (${ruleCount} rule${ruleCount === 1 ? "" : "s"})`);
   }
-  if (!cloud && existsSync32(cacheDir)) {
-    for (const f of readdirSync8(cacheDir)) {
+  if (!cloud && existsSync31(cacheDir)) {
+    for (const f of readdirSync7(cacheDir)) {
       if (f.endsWith(".json") && !keptCacheFiles.has(f)) {
         try {
-          rmSync4(join32(cacheDir, f));
+          rmSync4(join29(cacheDir, f));
         } catch {
         }
       }
@@ -13424,13 +13046,13 @@ var whoami_exports = {};
 __export(whoami_exports, {
   whoamiCommand: () => whoamiCommand
 });
-import { readFileSync as readFileSync31, existsSync as existsSync33 } from "fs";
-import { join as join33 } from "path";
-import { homedir as homedir33 } from "os";
+import { readFileSync as readFileSync29, existsSync as existsSync32 } from "fs";
+import { join as join30 } from "path";
+import { homedir as homedir30 } from "os";
 function readConfigEnv3() {
-  if (!existsSync33(CONFIG_PATH8)) return {};
+  if (!existsSync32(CONFIG_PATH8)) return {};
   const out = {};
-  for (const line of readFileSync31(CONFIG_PATH8, "utf-8").split("\n")) {
+  for (const line of readFileSync29(CONFIG_PATH8, "utf-8").split("\n")) {
     const t = line.trim();
     if (!t || t.startsWith("#")) continue;
     const eq = t.indexOf("=");
@@ -13440,8 +13062,8 @@ function readConfigEnv3() {
 }
 function jwtStatus() {
   try {
-    if (!existsSync33(JWT_PATH2)) return { status: "none" };
-    const jwt2 = readFileSync31(JWT_PATH2, "utf-8").trim();
+    if (!existsSync32(JWT_PATH2)) return { status: "none" };
+    const jwt2 = readFileSync29(JWT_PATH2, "utf-8").trim();
     if (!jwt2) return { status: "none" };
     const payload = jwt2.split(".")[1];
     if (!payload) return { status: "valid" };
@@ -13499,13 +13121,13 @@ async function whoamiCommand(args2 = []) {
   console.log("synkro identity");
   for (const [k, v] of rows) console.log(`  ${k.padEnd(width)}  ${v}`);
 }
-var SYNKRO_DIR15, CONFIG_PATH8, JWT_PATH2, GRADING_LABEL;
+var SYNKRO_DIR13, CONFIG_PATH8, JWT_PATH2, GRADING_LABEL;
 var init_whoami = __esm({
   "cli/commands/whoami.ts"() {
     "use strict";
-    SYNKRO_DIR15 = join33(homedir33(), ".synkro");
-    CONFIG_PATH8 = join33(SYNKRO_DIR15, "config.env");
-    JWT_PATH2 = join33(SYNKRO_DIR15, ".mcp-jwt");
+    SYNKRO_DIR13 = join30(homedir30(), ".synkro");
+    CONFIG_PATH8 = join30(SYNKRO_DIR13, "config.env");
+    JWT_PATH2 = join30(SYNKRO_DIR13, ".mcp-jwt");
     GRADING_LABEL = {
       local: "on-device worker pool",
       cloud: "Synkro Cloud worker pool",
@@ -13550,12 +13172,12 @@ __export(linear_exports, {
   formatLinks: () => formatLinks,
   linearCommand: () => linearCommand
 });
-import { readFileSync as readFileSync32 } from "fs";
-import { homedir as homedir34 } from "os";
-import { join as join34 } from "path";
+import { readFileSync as readFileSync30 } from "fs";
+import { homedir as homedir31 } from "os";
+import { join as join31 } from "path";
 function mcpJwt() {
   try {
-    return readFileSync32(join34(SYNKRO_DIR16, ".mcp-jwt"), "utf-8").trim();
+    return readFileSync30(join31(SYNKRO_DIR14, ".mcp-jwt"), "utf-8").trim();
   } catch {
     return "";
   }
@@ -13590,11 +13212,11 @@ async function linearCommand(_args = []) {
   }
   console.log(formatLinks(links));
 }
-var SYNKRO_DIR16, PORT2, BASE;
+var SYNKRO_DIR14, PORT2, BASE;
 var init_linear = __esm({
   "cli/commands/linear.ts"() {
     "use strict";
-    SYNKRO_DIR16 = join34(homedir34(), ".synkro");
+    SYNKRO_DIR14 = join31(homedir31(), ".synkro");
     PORT2 = process.env.SYNKRO_MCP_PORT || "18931";
     BASE = `http://127.0.0.1:${PORT2}`;
   }
@@ -13602,7 +13224,7 @@ var init_linear = __esm({
 
 // cli/scanning/cveReachability.ts
 import { parse } from "@babel/parser";
-import { readFileSync as readFileSync33 } from "fs";
+import { readFileSync as readFileSync31 } from "fs";
 function walk(node, visit) {
   if (!node || typeof node.type !== "string") return;
   visit(node);
@@ -13743,10 +13365,10 @@ var init_cveReachability = __esm({
 });
 
 // cli/reachability/reachabilityScan.ts
-import { spawnSync as spawnSync12, execFileSync as execFileSync5 } from "child_process";
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync25, existsSync as existsSync34, readdirSync as readdirSync9 } from "fs";
-import { join as join35 } from "path";
-import { homedir as homedir35 } from "os";
+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 { createRequire } from "module";
 function walkSourceFiles(repoRoot2, 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"]);
@@ -13757,13 +13379,13 @@ function walkSourceFiles(repoRoot2, maxFiles = 4e3, maxBytes = 5e5) {
     const dir = stack.pop();
     let ents;
     try {
-      ents = readdirSync9(dir, { withFileTypes: true });
+      ents = readdirSync8(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of ents) {
       if (files.length >= maxFiles) break;
-      const full = join35(dir, e.name);
+      const full = join32(dir, e.name);
       if (e.isDirectory()) {
         if (!SKIP.has(e.name) && !e.name.startsWith(".")) stack.push(full);
         continue;
@@ -13771,7 +13393,7 @@ function walkSourceFiles(repoRoot2, maxFiles = 4e3, maxBytes = 5e5) {
       if (!EXT.test(e.name) || e.name.endsWith(".d.ts")) continue;
       const rel = full.startsWith(repoRoot2 + "/") ? full.slice(repoRoot2.length + 1) : full;
       try {
-        const content = readFileSync34(full, "utf8");
+        const content = readFileSync32(full, "utf8");
         if (content.length <= maxBytes) files.push({ path: rel, content });
       } catch {
       }
@@ -13790,12 +13412,12 @@ function cleanVersion(spec) {
 function gatherManifestVersions(repoRoot2) {
   const out = {};
   const dirs = [repoRoot2];
-  const pkgsDir = join35(repoRoot2, "packages");
-  if (existsSync34(pkgsDir)) {
+  const pkgsDir = join32(repoRoot2, "packages");
+  if (existsSync33(pkgsDir)) {
     try {
-      for (const d of readdirSync9(pkgsDir)) {
-        const pd = join35(pkgsDir, d);
-        if (existsSync34(join35(pd, "package.json"))) dirs.push(pd);
+      for (const d of readdirSync8(pkgsDir)) {
+        const pd = join32(pkgsDir, d);
+        if (existsSync33(join32(pd, "package.json"))) dirs.push(pd);
       }
     } catch {
     }
@@ -13804,7 +13426,7 @@ function gatherManifestVersions(repoRoot2) {
   for (const dir of dirs) {
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync34(join35(dir, "package.json"), "utf8"));
+      pkg = JSON.parse(readFileSync32(join32(dir, "package.json"), "utf8"));
     } catch {
       continue;
     }
@@ -13824,28 +13446,28 @@ function findJelly(repoRoot2) {
   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(readFileSync34(pkgJson, "utf8"));
+    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 = join35(dir, bin);
-      if (existsSync34(p)) return p;
+      const p = join32(dir, bin);
+      if (existsSync33(p)) return p;
     }
   } catch {
   }
   for (const base of [repoRoot2, process.cwd()]) {
-    const b = join35(base, "node_modules", ".bin", "jelly");
-    if (existsSync34(b)) return b;
+    const b = join32(base, "node_modules", ".bin", "jelly");
+    if (existsSync33(b)) return b;
   }
   return null;
 }
 function findEntries(repoRoot2) {
   const dirs = [repoRoot2];
-  const pkgsDir = join35(repoRoot2, "packages");
-  if (existsSync34(pkgsDir)) {
+  const pkgsDir = join32(repoRoot2, "packages");
+  if (existsSync33(pkgsDir)) {
     try {
-      for (const d of readdirSync9(pkgsDir)) {
-        const pd = join35(pkgsDir, d);
-        if (existsSync34(join35(pd, "package.json"))) dirs.push(pd);
+      for (const d of readdirSync8(pkgsDir)) {
+        const pd = join32(pkgsDir, d);
+        if (existsSync33(join32(pd, "package.json"))) dirs.push(pd);
       }
     } catch {
     }
@@ -13853,12 +13475,12 @@ function findEntries(repoRoot2) {
   const entries = [];
   for (const dir of dirs) {
     try {
-      const pkg = JSON.parse(readFileSync34(join35(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync32(join32(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 = join35(dir, c);
-        if (existsSync34(f)) {
+        const f = join32(dir, c);
+        if (existsSync33(f)) {
           entries.push(f);
           break;
         }
@@ -13891,9 +13513,9 @@ function parseApiUsage(log) {
 }
 function runReachabilityScan(repoRoot2, opts = {}) {
   const commit = currentCommit(repoRoot2);
-  if (!opts.force && commit && existsSync34(REACHABILITY_PATH)) {
+  if (!opts.force && commit && existsSync33(REACHABILITY_PATH)) {
     try {
-      const prev = JSON.parse(readFileSync34(REACHABILITY_PATH, "utf8"));
+      const prev = JSON.parse(readFileSync32(REACHABILITY_PATH, "utf8"));
       if (prev.commit === commit) return { ok: true, cached: true, packages: Object.keys(prev.packages || {}).length };
     } catch {
     }
@@ -13944,7 +13566,7 @@ function runReachabilityScan(repoRoot2, opts = {}) {
   if (jelly) {
     const entries = findEntries(repoRoot2);
     if (entries.length > 0) {
-      const r = spawnSync12(
+      const r = spawnSync11(
         process.execPath,
         [jelly, "-b", repoRoot2, "--api-usage", ...entries],
         { encoding: "utf8", timeout: opts.timeoutMs ?? 18e4, maxBuffer: 2e8 }
@@ -13982,7 +13604,7 @@ function runReachabilityScan(repoRoot2, opts = {}) {
   if (Object.keys(packages).length === 0) return { ok: false, reason: "no package usage found (no jelly output, no AST imports)" };
   const file = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), commit, tool, packages, versions: gatherManifestVersions(repoRoot2) };
   try {
-    writeFileSync25(REACHABILITY_PATH, JSON.stringify(file, null, 2));
+    writeFileSync22(REACHABILITY_PATH, JSON.stringify(file, null, 2));
   } catch (e) {
     return { ok: false, reason: "write failed: " + String(e.message || e) };
   }
@@ -13994,7 +13616,7 @@ var init_reachabilityScan = __esm({
     "use strict";
     init_cveReachability();
     require2 = createRequire(import.meta.url);
-    REACHABILITY_PATH = join35(homedir35(), ".synkro", "reachability.json");
+    REACHABILITY_PATH = join32(homedir32(), ".synkro", "reachability.json");
   }
 });
 
@@ -14003,15 +13625,15 @@ var reachabilityScan_exports = {};
 __export(reachabilityScan_exports, {
   reachabilityScanCommand: () => reachabilityScanCommand
 });
-import { readFileSync as readFileSync35, existsSync as existsSync35 } from "fs";
-import { join as join36 } from "path";
-import { homedir as homedir36 } from "os";
+import { readFileSync as readFileSync33, existsSync as existsSync34 } from "fs";
+import { join as join33 } from "path";
+import { homedir as homedir33 } from "os";
 import { execFileSync as execFileSync6 } from "child_process";
 function readConfigEnv4() {
-  const p = join36(SYNKRO_DIR17, "config.env");
-  if (!existsSync35(p)) return {};
+  const p = join33(SYNKRO_DIR15, "config.env");
+  if (!existsSync34(p)) return {};
   const out = {};
-  for (const line of readFileSync35(p, "utf-8").split("\n")) {
+  for (const line of readFileSync33(p, "utf-8").split("\n")) {
     const t = line.trim();
     if (!t || t.startsWith("#")) continue;
     const eq = t.indexOf("=");
@@ -14043,11 +13665,11 @@ async function pushToCloud(cfg, repo) {
   while (gwBase.endsWith("/")) gwBase = gwBase.slice(0, -1);
   let jwt2 = "";
   try {
-    jwt2 = readFileSync35(join36(SYNKRO_DIR17, ".mcp-jwt"), "utf-8").trim();
+    jwt2 = readFileSync33(join33(SYNKRO_DIR15, ".mcp-jwt"), "utf-8").trim();
   } catch {
   }
-  if (!jwt2 || !existsSync35(REACHABILITY_PATH)) return;
-  const body = readFileSync35(REACHABILITY_PATH, "utf-8");
+  if (!jwt2 || !existsSync34(REACHABILITY_PATH)) return;
+  const body = readFileSync33(REACHABILITY_PATH, "utf-8");
   try {
     const resp = await fetch(gwBase + "/api/v1/reachability?repo=" + encodeURIComponent(repo), {
       method: "POST",
@@ -14074,12 +13696,12 @@ async function reachabilityScanCommand(args2 = []) {
   const isCloud = cfg.SYNKRO_DEPLOY_LOCATION === "cloud" || cfg.SYNKRO_STORAGE_MODE === "cloud";
   if (isCloud) await pushToCloud(cfg, cfg.SYNKRO_CONNECTED_REPO || repoSlug(root));
 }
-var SYNKRO_DIR17;
+var SYNKRO_DIR15;
 var init_reachabilityScan2 = __esm({
   "cli/commands/reachabilityScan.ts"() {
     "use strict";
     init_reachabilityScan();
-    SYNKRO_DIR17 = join36(homedir36(), ".synkro");
+    SYNKRO_DIR15 = join33(homedir33(), ".synkro");
   }
 });
 
@@ -14209,13 +13831,13 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { readFileSync as readFileSync36, writeFileSync as writeFileSync26, existsSync as existsSync36 } from "fs";
-import { join as join37 } from "path";
-import { homedir as homedir37 } from "os";
+import { readFileSync as readFileSync34, writeFileSync as writeFileSync23, existsSync as existsSync35 } from "fs";
+import { join as join34 } from "path";
+import { homedir as homedir34 } from "os";
 function readConfigEnv5() {
-  if (!existsSync36(CONFIG_PATH9)) return {};
+  if (!existsSync35(CONFIG_PATH9)) return {};
   const out = {};
-  for (const line of readFileSync36(CONFIG_PATH9, "utf-8").split("\n")) {
+  for (const line of readFileSync34(CONFIG_PATH9, "utf-8").split("\n")) {
     const t = line.trim();
     if (!t || t.startsWith("#")) continue;
     const eq = t.indexOf("=");
@@ -14224,11 +13846,11 @@ function readConfigEnv5() {
   return out;
 }
 function updateConfigValue(key, value) {
-  if (!existsSync36(CONFIG_PATH9)) {
+  if (!existsSync35(CONFIG_PATH9)) {
     console.error("No config found. Run `synkro install` first.");
     process.exit(1);
   }
-  const lines = readFileSync36(CONFIG_PATH9, "utf-8").split("\n");
+  const lines = readFileSync34(CONFIG_PATH9, "utf-8").split("\n");
   const pattern = new RegExp(`^${key}=`);
   let found = false;
   const updated = lines.map((line) => {
@@ -14239,7 +13861,7 @@ function updateConfigValue(key, value) {
     return line;
   });
   if (!found) updated.splice(updated.length - 1, 0, `${key}='${value}'`);
-  writeFileSync26(CONFIG_PATH9, updated.join("\n"), "utf-8");
+  writeFileSync23(CONFIG_PATH9, updated.join("\n"), "utf-8");
 }
 function resolveInferenceMode(cfg) {
   if ((cfg.SYNKRO_GRADING_MODE || "local") === "byok") return "byok";
@@ -14391,14 +14013,14 @@ To change:`);
   }
   if (inferenceValue !== "cloud") await reconcileContainer();
 }
-var SYNKRO_DIR18, CONFIG_PATH9;
+var SYNKRO_DIR16, CONFIG_PATH9;
 var init_config = __esm({
   "cli/commands/config.ts"() {
     "use strict";
     init_stub();
     init_optout();
-    SYNKRO_DIR18 = join37(homedir37(), ".synkro");
-    CONFIG_PATH9 = join37(SYNKRO_DIR18, "config.env");
+    SYNKRO_DIR16 = join34(homedir34(), ".synkro");
+    CONFIG_PATH9 = join34(SYNKRO_DIR16, "config.env");
   }
 });
 
@@ -14587,14 +14209,14 @@ Usage:
 });
 
 // cli/bootstrap.js
-import { readFileSync as readFileSync37, existsSync as existsSync37 } from "fs";
+import { readFileSync as readFileSync35, existsSync as existsSync36 } from "fs";
 import { resolve as resolve5 } from "path";
 var envCandidates = [
   resolve5(process.env.HOME ?? "", ".synkro", "config.env")
 ];
 for (const envPath of envCandidates) {
-  if (!existsSync37(envPath)) continue;
-  const envContent = readFileSync37(envPath, "utf-8");
+  if (!existsSync36(envPath)) continue;
+  const envContent = readFileSync35(envPath, "utf-8");
   for (const line of envContent.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
@@ -14611,7 +14233,7 @@ 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", ""]);
 function printVersion() {
-  console.log("1.7.92");
+  console.log("1.7.93");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents
@@ -14703,79 +14325,17 @@ async function main() {
       await scanPrCommand2();
       break;
     }
-    case "route": {
-      const { injectModel: injectModel2 } = await Promise.resolve().then(() => (init_ptyShim(), ptyShim_exports));
-      const model = (subArgs[0] || "").trim();
-      const sessionOverride = (subArgs[1] || "").trim() || void 0;
-      if (model) {
-        try {
-          injectModel2(model, sessionOverride);
-        } catch {
-        }
-      }
-      break;
-    }
-    case "route-decide": {
-      const { routeDecide: routeDecide2 } = await Promise.resolve().then(() => (init_routeDecide(), routeDecide_exports));
-      const sid = (subArgs[0] || "").trim();
-      if (sid) {
-        try {
-          await routeDecide2(sid);
-        } catch {
-        }
-      }
-      break;
-    }
-    case "route-and-resubmit": {
-      const { routeAndResubmit: routeAndResubmit2 } = await Promise.resolve().then(() => (init_routeOrchestrate(), routeOrchestrate_exports));
-      const sid = (subArgs[0] || "").trim();
-      const task = (subArgs[1] || "").trim();
-      const tmuxSession = (subArgs[2] || "").trim() || void 0;
-      const forceModel = (subArgs[3] || "").trim() || void 0;
-      if (sid && task) {
-        try {
-          await routeAndResubmit2(sid, task, tmuxSession, forceModel);
-        } catch {
-        }
-      }
-      break;
-    }
-    case "routing": {
-      const { routingCommand: routingCommand2 } = await Promise.resolve().then(() => (init_routingToggle(), routingToggle_exports));
-      routingCommand2(subArgs);
-      break;
-    }
+    case "route":
+    case "route-decide":
+    case "route-and-resubmit":
+    case "routing":
     case "sessions": {
-      const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_ptyShim(), ptyShim_exports));
-      const rows = listSessions2({ liveOnly: !subArgs.includes("--all") });
-      if (rows.length === 0) {
-        console.log("No active Synkro-wrapped Claude Code sessions.");
-        console.log("(Start one with `claude`; it registers on your first prompt.)");
-        break;
-      }
-      const now = Date.now();
-      const age = (ts) => {
-        const s = Math.max(0, Math.round((now - (ts || 0)) / 1e3));
-        if (s < 60) return `${s}s`;
-        if (s < 3600) return `${Math.round(s / 60)}m`;
-        return `${Math.round(s / 3600)}h`;
-      };
-      console.log(`${rows.length} session${rows.length === 1 ? "" : "s"}:
-`);
-      for (const r of rows) {
-        console.log(`  ${r.session_id}  (${age(r.ts)} ago)`);
-        if (r.cwd) console.log(`    cwd:    ${r.cwd}`);
-        if (r.last_prompt) console.log(`    prompt: ${r.last_prompt.replace(/\s+/g, " ").slice(0, 80)}`);
-        console.log(`    route:  echo <model> > ~/.synkro/pty/route-${r.session_id}`);
-        console.log();
-      }
+      console.error("Synkro host model routing has been removed.");
       break;
     }
     case "pty-shim": {
-      const { installPtyShim: installPtyShim2, uninstallPtyShim: uninstallPtyShim2 } = await Promise.resolve().then(() => (init_ptyShim(), ptyShim_exports));
-      const sub = (subArgs[0] || "install").trim();
-      if (sub === "uninstall" || sub === "remove") uninstallPtyShim2();
-      else installPtyShim2();
+      const { uninstallPtyShim: uninstallPtyShim2 } = await Promise.resolve().then(() => (init_ptyShim(), ptyShim_exports));
+      uninstallPtyShim2();
       break;
     }
     case "local-cc": {