@synkro-sh/cli 1.10.3 → 1.10.4

package/dist/bootstrap.js

@@ -147,7 +147,7 @@ function getIdentity() {
   if (cached2) return cached2;
   let cliVersion2 = "0.0.0";
   try {
-    cliVersion2 = "1.10.3";
+    cliVersion2 = "1.10.4";
   } catch {
   }
   const creds = loadCredentialsIdentity();
@@ -7840,7 +7840,7 @@ var init_dockerInstall = __esm({
     HOST_PGLITE_PORT = parseInt(process.env.SYNKRO_HOST_PGLITE_PORT || "15433", 10);
     CONTAINER_NAME = resolveContainerName();
     defaultImageVersion = () => {
-      if (true) return "1.10.3";
+      if (true) return "1.10.4";
       try {
         const pkg = JSON.parse(readFileSync17(new URL("../../package.json", import.meta.url), "utf8"));
         if (pkg.version) return pkg.version;
@@ -8900,7 +8900,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle2(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle2(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle2(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle2("1.10.3")}`
+    `SYNKRO_VERSION=${shellQuoteSingle2("1.10.4")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle2(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle2(safeUserId)}`);
@@ -9647,7 +9647,7 @@ async function installCommand(opts = {}) {
   await setTelemetryState({ enabled: true, remoteFlushEnabled: telemetryConsent });
   emit("install", {
     phase: "started",
-    cli_version_to: "1.10.3",
+    cli_version_to: "1.10.4",
     agents_detected: agents.map((a) => a.kind),
     with_github: false,
     with_local_cc: false,
@@ -10630,15 +10630,15 @@ async function discoverAndIngestSkills() {
     }
     const found = discoverSkillFiles(repoRoot3, excludeHashes, ingestedHashes, ingestedNames);
     if (found.length === 0) return;
-    const selectable = found.filter((f) => !f.ingested);
-    if (selectable.length === 0) {
+    const selectable2 = found.filter((f) => !f.ingested);
+    if (selectable2.length === 0) {
       const names = found.map((f) => f.name);
       const shown = names.slice(0, 5).join(", ") + (names.length > 5 ? `, +${names.length - 5} more` : "");
       console.log(`
 \u2713 ${found.length} skill${found.length === 1 ? "" : "s"} already ingested (${shown}) \u2014 nothing new to add.`);
       return;
     }
-    const setHash = discoverySetHash(selectable);
+    const setHash = discoverySetHash(selectable2);
     let prev = "";
     try {
       prev = readFileSync21(SKILLS_DISCOVERED_PATH, "utf-8").trim();
@@ -14540,6 +14540,10 @@ function buildSpawnAgent(opts) {
   return [
     ["tmux", "new-session", "-d", "-s", session, "-c", opts.cwd, opts.command],
     ["tmux", "set-option", "-t", session, "status", "off"],
+    // Mouse on inside the agent session too, so the wheel reaches the harness
+    // and its own history scrolls — without it only the last screen is
+    // reachable once the session is nested inside the layout.
+    ["tmux", "set-option", "-t", session, "mouse", "on"],
     ["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],
@@ -14549,10 +14553,32 @@ function buildSpawnAgent(opts) {
   ];
 }
 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)];
+  return ["tmux", "list-sessions", "-F", ["#{session_name}", "#{?pane_dead,dead,alive}", "#{@synkro_harness}", "#{@synkro_space}", "#{@synkro_backend}", "#{@synkro_pueue}", "#{pane_current_path}"].join(FIELD_SEP)];
+}
+function buildAgentSnapshot() {
+  const list = buildListAgents().map(shellQuote3).join(" ");
+  const script = list + ' 2>/dev/null; tmux list-sessions -F "#{session_name}" 2>/dev/null | grep "^' + AGENT_PREFIX + '" | while IFS= read -r s; do printf "===%s\\n" "$s"; tmux capture-pane -p -t "$s" 2>/dev/null; done';
+  return ["sh", "-c", script];
+}
+function parseAgentSnapshot(output) {
+  const lines = String(output || "").split("\n");
+  const captures = /* @__PURE__ */ new Map();
+  const listLines = [];
+  let current = null;
+  let chunk = [];
+  const flush2 = () => {
+    if (current) captures.set(current, chunk.join("\n"));
+  };
+  for (const line of lines) {
+    if (line.startsWith("===")) {
+      flush2();
+      current = line.slice(3).trim();
+      chunk = [];
+    } else if (current) chunk.push(line);
+    else listLines.push(line);
+  }
+  flush2();
+  return { list: listLines.join("\n"), captures };
 }
 function buildKillSession(session) {
   return ["tmux", "kill-session", "-t", session];
@@ -14566,9 +14592,31 @@ function buildSendText(session, text) {
     ["tmux", "send-keys", "-t", session, "Enter"]
   ];
 }
+function buildEnableMouse(session) {
+  return ["tmux", "set-option", "-t", session, "mouse", "on"];
+}
 function buildInterrupt(session) {
   return ["tmux", "send-keys", "-t", session, "Escape"];
 }
+function buildDialogPopup(opts) {
+  const command = ["node", opts.bootPath, "ui", "--dialog", opts.kind, opts.cwd, ...opts.args || []].map(shellQuote3).join(" ");
+  return [
+    "tmux",
+    "display-popup",
+    "-c",
+    opts.client,
+    "-E",
+    "-w",
+    opts.width,
+    "-h",
+    opts.height,
+    "-S",
+    "fg=colour111",
+    "-d",
+    opts.cwd,
+    command
+  ];
+}
 function buildCenterAttachCommand(runner, session) {
   const argv = runnerInteractiveArgs(runner, ["tmux", "attach-session", "-t", session]);
   return "env TMUX= " + argv.map(shellQuote3).join(" ");
@@ -14582,7 +14630,9 @@ function parseAgentSessions(output, backend) {
     name: cols[0].slice(AGENT_PREFIX.length),
     dead: cols[1] === "dead",
     harness: cols[2] || "claude",
-    space: cols[3] || "",
+    // Only an absolute path is usable; anything else falls back to where
+    // the pane actually is.
+    space: (cols[3] || "").startsWith("/") ? cols[3] : cols[6] || "",
     backend: cols[4] || backend,
     pueue: cols[5] || ""
   }));
@@ -14623,99 +14673,10 @@ var init_tmux = __esm({
   }
 });
 
-// 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
+import { existsSync as existsSync34, mkdirSync as mkdirSync20, readFileSync as readFileSync30, writeFileSync as writeFileSync23 } from "fs";
+import { homedir as homedir32 } from "os";
+import { dirname as dirname9, join as join32 } from "path";
 function detectAsk(tail2) {
   for (const marker of BLOCK_MARKERS) {
     if (marker.pattern.test(String(tail2 || ""))) return marker.ask;
@@ -14726,7 +14687,9 @@ 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" };
+  if (input.changed) return { status: "working" };
+  if (input.wasWorking && !input.seen) return { status: "replied" };
+  return { status: "idle" };
 }
 function hashTail(tail2) {
   let hash = 0;
@@ -14759,39 +14722,110 @@ async function fetchConductorTasks(baseUrl) {
     return [];
   }
 }
-async function discoverHostSpaces(repoCwd) {
-  const result = await run({ kind: "host" }, ["git", "-C", repoCwd, "worktree", "list", "--porcelain"]);
+function parseTrack(raw) {
+  const ahead = String(raw || "").match(/ahead (\d+)/);
+  const behind = String(raw || "").match(/behind (\d+)/);
+  return [ahead && ahead[1] !== "0" ? "\u2191" + ahead[1] : "", behind && behind[1] !== "0" ? "\u2193" + behind[1] : ""].filter(Boolean).join(" ");
+}
+function canonicalSpacePath(path) {
+  const clean = String(path || "").replace(/\/+$/, "");
+  const managed = clean.match(/^(.+?)\/\.(?:claude|codex)\//);
+  if (managed) return existsSync34(join32(managed[1], ".git")) ? managed[1] : "";
+  return clean;
+}
+function loadSpaceList() {
+  try {
+    const parsed = JSON.parse(readFileSync30(SPACES_FILE, "utf8"));
+    return Array.isArray(parsed) ? [...new Set(parsed.filter((path) => typeof path === "string").map((path) => path.replace(/\/+$/, "")).filter(Boolean))] : [];
+  } catch {
+    return [];
+  }
+}
+function saveSpaceList(list) {
+  try {
+    mkdirSync20(dirname9(SPACES_FILE), { recursive: true });
+    writeFileSync23(SPACES_FILE, JSON.stringify(list, null, 2));
+  } catch {
+  }
+}
+function rememberSpace(path) {
+  const clean = String(path || "").replace(/\/+$/, "");
+  if (!clean) return;
+  const list = loadSpaceList();
+  if (list.includes(clean)) return;
+  saveSpaceList([...list, clean]);
+}
+function forgetSpace(path) {
+  const clean = canonicalSpacePath(path);
+  saveSpaceList(loadSpaceList().filter((entry) => entry !== clean));
+}
+async function listWorktrees(repoPath) {
+  const result = await run({ kind: "host" }, ["git", "-C", repoPath, "worktree", "list", "--porcelain"]);
   if (!result.ok) return [];
-  return parseWorktrees(result.stdout).map((row2) => ({
-    name: row2.name,
-    branch: row2.branch,
+  return parseWorktrees(result.stdout).map((row2, index) => ({
     path: row2.path,
-    backend: "host"
+    branch: row2.branch,
+    note: index === 0 ? "checkout" : row2.branch === "detached" ? "detached" : "",
+    primary: index === 0
   }));
 }
-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 repoOf(path) {
+  const result = await run({ kind: "host" }, ["git", "-C", path, "worktree", "list", "--porcelain"]);
+  if (!result.ok) return canonicalSpacePath(path);
+  const first = parseWorktrees(result.stdout)[0];
+  return first ? first.path.replace(/\/+$/, "") : canonicalSpacePath(path);
+}
+async function discoverHostSpaces(repoCwd) {
+  const host = { kind: "host" };
+  const paths = [repoCwd, ...loadSpaceList()].map((path) => String(path || "").replace(/\/+$/, "")).filter(Boolean);
+  const spaces = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const root = await repoOf(path);
+    if (!root || seen.has(root)) continue;
+    seen.add(root);
+    const status = await run(host, ["git", "-C", root, "status", "--porcelain=v2", "--branch", "--no-renames"]);
+    const branch = status.stdout.match(/^# branch\.head (.+)$/m)?.[1] || "";
+    const ab = status.stdout.match(/^# branch\.ab \+(\d+) -(\d+)$/m);
+    spaces.push({
+      name: root.split("/").filter(Boolean).pop() || root,
+      branch: branch === "(detached)" ? "detached" : branch,
+      path: root,
+      backend: "host",
+      track: ab ? parseTrack("ahead " + ab[1] + ", behind " + ab[2]) : ""
+    });
+  }
+  return spaces;
 }
-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();
+function visibleAgents(all, space, filter, grouped) {
+  if (grouped || filter === "all" || !space) return all;
+  return all.filter((agent) => agent.repo === space.path);
+}
+async function discoverAgents(runner, backend, memory) {
+  const snapshot = await run(runner, buildAgentSnapshot());
+  const { list, captures } = parseAgentSnapshot(snapshot.ok ? snapshot.stdout : "");
+  const rows = parseAgentSessions(list, backend);
+  const next = /* @__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 tail2 = row2.dead ? "" : captures.get(row2.session) || "";
     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 });
+    const previous = memory.get(row2.session);
+    const changed = previous !== void 0 && previous.hash !== nextHash;
+    const seen = previous?.seen ?? false;
+    const derived = deriveStatus({
+      dead: row2.dead,
+      tail: tail2,
+      changed,
+      // Remember a turn was running until the user actually looks at it.
+      wasWorking: changed || (previous?.wasWorking ?? false),
+      seen
+    });
+    next.set(row2.session, {
+      hash: nextHash,
+      wasWorking: seen ? false : changed || (previous?.wasWorking ?? false),
+      seen: changed ? false : seen
+    });
     agents.push({
       name: row2.name,
       session: row2.session,
@@ -14802,9 +14836,20 @@ async function discoverAgents(runner, backend, previousHashes) {
       ask: derived.ask
     });
   }
-  return { agents, hashes };
+  return { agents, memory: next };
+}
+function offlineAgents(live, records) {
+  const alive = new Set(live.map((agent) => agent.session));
+  return records.filter((record) => !alive.has(record.session)).map((record) => ({
+    name: record.name,
+    session: record.session,
+    harness: record.harness,
+    space: record.space,
+    backend: record.backend,
+    status: "offline"
+  }));
 }
-var BLOCK_MARKERS;
+var BLOCK_MARKERS, SPACES_FILE;
 var init_model = __esm({
   "cli/ui/model.ts"() {
     "use strict";
@@ -14814,6 +14859,301 @@ var init_model = __esm({
       { pattern: /\[synkro:task-workspace|\[synkro:scm|keep working in the current workspace/i, ask: "workspace" },
       { pattern: /⛔/, ask: "tracking" }
     ];
+    SPACES_FILE = join32(homedir32(), ".synkro", "ui-spaces.json");
+  }
+});
+
+// cli/ui/manifest.ts
+import { mkdirSync as mkdirSync21, readFileSync as readFileSync31, writeFileSync as writeFileSync24 } from "fs";
+import { homedir as homedir33 } from "os";
+import { dirname as dirname10, join as join33 } from "path";
+function loadRecords() {
+  try {
+    const parsed = JSON.parse(readFileSync31(MANIFEST_FILE, "utf8"));
+    return Array.isArray(parsed) ? parsed.filter((row2) => row2 && typeof row2.session === "string" && typeof row2.space === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function saveRecords(records) {
+  try {
+    mkdirSync21(dirname10(MANIFEST_FILE), { recursive: true });
+    writeFileSync24(MANIFEST_FILE, JSON.stringify(records, null, 2));
+  } catch {
+  }
+}
+function recordSession(record) {
+  saveRecords([...loadRecords().filter((row2) => row2.session !== record.session), record]);
+}
+function forgetSession(session) {
+  saveRecords(loadRecords().filter((row2) => row2.session !== session));
+}
+function resumeCommand(harness) {
+  return RESUME_COMMANDS[harness] || RESUME_COMMANDS.claude;
+}
+function loadTabs() {
+  try {
+    const parsed = JSON.parse(readFileSync31(TABS_FILE, "utf8"));
+    return Array.isArray(parsed) ? parsed.filter((row2) => row2 && typeof row2.cwd === "string" && typeof row2.kind === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function saveTabs(tabs) {
+  try {
+    mkdirSync21(dirname10(TABS_FILE), { recursive: true });
+    writeFileSync24(TABS_FILE, JSON.stringify(tabs, null, 2));
+  } catch {
+  }
+}
+function loadLastAgents() {
+  try {
+    const parsed = JSON.parse(readFileSync31(LAST_AGENT_FILE, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function lastAgentFor(space) {
+  return loadLastAgents()[String(space || "").replace(/\/+$/, "")] || "";
+}
+function rememberLastAgent(space, session) {
+  const key = String(space || "").replace(/\/+$/, "");
+  if (!key || !session) return;
+  try {
+    mkdirSync21(dirname10(LAST_AGENT_FILE), { recursive: true });
+    writeFileSync24(LAST_AGENT_FILE, JSON.stringify({ ...loadLastAgents(), [key]: session }, null, 2));
+  } catch {
+  }
+}
+function loadRepos() {
+  try {
+    const parsed = JSON.parse(readFileSync31(REPOS_FILE, "utf8"));
+    return Array.isArray(parsed) ? parsed.filter((path) => typeof path === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function rememberRepo(path) {
+  const clean = String(path || "").replace(/\/+$/, "");
+  if (!clean) return;
+  const next = [clean, ...loadRepos().filter((entry) => entry !== clean)].slice(0, 40);
+  try {
+    mkdirSync21(dirname10(REPOS_FILE), { recursive: true });
+    writeFileSync24(REPOS_FILE, JSON.stringify(next, null, 2));
+  } catch {
+  }
+}
+var MANIFEST_FILE, RESUME_COMMANDS, TABS_FILE, LAST_AGENT_FILE, REPOS_FILE;
+var init_manifest = __esm({
+  "cli/ui/manifest.ts"() {
+    "use strict";
+    MANIFEST_FILE = join33(homedir33(), ".synkro", "ui-sessions.json");
+    RESUME_COMMANDS = {
+      claude: "claude --continue",
+      codex: "codex resume --last",
+      cursor: "cursor-agent --continue"
+    };
+    TABS_FILE = join33(homedir33(), ".synkro", "ui-tabs.json");
+    LAST_AGENT_FILE = join33(homedir33(), ".synkro", "ui-last-agent.json");
+    REPOS_FILE = join33(homedir33(), ".synkro", "ui-repos.json");
+  }
+});
+
+// cli/ui/launch.ts
+import { mkdirSync as mkdirSync22, writeFileSync as writeFileSync25 } from "fs";
+import { homedir as homedir34 } from "os";
+import { join as join34 } from "path";
+function sidebarColumns(totalColumns) {
+  return String(Math.max(20, Math.min(34, Math.round(totalColumns * 0.24))));
+}
+async function currentWindowColumns(windowTarget) {
+  const asked = await run(HOST, ["tmux", "display-message", "-p", "-t", windowTarget, "#{window_width}"]);
+  return Number(asked.stdout.trim()) || Number(process.stdout.columns || 0) || 220;
+}
+function makeTerminalCommand(bootPath) {
+  if (!(process.env.SHELL || "").endsWith("zsh")) return void 0;
+  const dir = join34(homedir34(), ".synkro", "ui-shell");
+  const wrap2 = (command, kind) => command + "() { if whence -p " + command + ' >/dev/null 2>&1; then exec node "$SYNKRO_UI_BOOT" ui --takeover ' + kind + ' "$PWD"; else echo "zsh: command not found: ' + command + '" >&2; return 127; fi; }';
+  try {
+    mkdirSync22(dir, { recursive: true });
+    writeFileSync25(join34(dir, ".zshenv"), '[ -f "$HOME/.zshenv" ] && source "$HOME/.zshenv"\n');
+    writeFileSync25(join34(dir, ".zshrc"), [
+      '[ -f "$HOME/.zshrc" ] && source "$HOME/.zshrc"',
+      wrap2("claude", "claude"),
+      wrap2("codex", "codex"),
+      wrap2("cursor-agent", "cursor"),
+      ""
+    ].join("\n"));
+  } catch {
+    return void 0;
+  }
+  return "env ZDOTDIR=" + shellQuote3(dir) + " SYNKRO_UI_BOOT=" + shellQuote3(bootPath) + " zsh -i";
+}
+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";
+}
+function writeDialogLauncher(name, bootPath, kind, repoCwd, args2 = []) {
+  const dir = join34(homedir34(), ".synkro", "ui-shell");
+  const target = join34(dir, name);
+  try {
+    mkdirSync22(dir, { recursive: true });
+    writeFileSync25(target, [
+      "#!/bin/sh",
+      ["exec node", shellQuote3(bootPath), "ui --dialog", kind, shellQuote3(repoCwd), ...args2.map(shellQuote3)].join(" "),
+      ""
+    ].join("\n"), { mode: 493 });
+  } catch {
+  }
+  return target;
+}
+function shortSpace(name) {
+  const value = String(name || "");
+  return value.length <= 14 ? value : value.slice(0, 13) + "\u2026";
+}
+function tabTitle(kind, spaceName) {
+  const glyph = TAB_GLYPHS[kind] || TAB_GLYPHS.terminal;
+  if (kind === "terminal" || kind === "settings") return glyph + " " + shortSpace(spaceName);
+  return glyph + " " + kind + (spaceName ? " " + shortSpace(spaceName) : "");
+}
+function chipStrip(sidebarWidth) {
+  const chip = "#[range=window|#{window_index}]#{?window_active,#[bg=colour111]#[fg=colour233]#[bold]  #W  #[default],#[fg=colour245]  #W  }#[norange]";
+  const brand = " \u29C9 synkro ";
+  const gap = " ".repeat(Math.max(1, sidebarWidth + 1 - brand.length));
+  return "#[align=left]#[fg=colour111]#[bold]" + brand + "#[default]" + gap + "#{W:" + chip + "}#[range=user|tabmenu]#[fg=colour245]  \xD7  #[norange]#[range=user|newtab]#[fg=colour240]  +  #[norange]#[default]";
+}
+async function styleOuterSession(bootPath, repoCwd, sidebarWidth) {
+  const launcher = writeDialogLauncher("new-tab", bootPath, "new-tab", repoCwd);
+  const tabLauncher = writeDialogLauncher("tab-menu", bootPath, "tab", repoCwd, [UI_SESSION]);
+  const popup = "display-popup -E -w 80% -h 70% -S fg=colour111 " + shellQuote3(launcher);
+  const tabPopup = "display-popup -E -w 60 -h 18 -S fg=colour111 " + shellQuote3(tabLauncher);
+  const dispatch = 'if-shell -F "#{==:#{mouse_status_range},tabmenu}" "' + tabPopup + '" "select-window -t="';
+  const style = [
+    // Mouse: drag the pane border to resize the sidebar, click a pane to
+    // focus it, click rows/chips. Without this the fixed split reads as
+    // "blocked in".
+    ["set-option", "-t", UI_SESSION, "mouse", "on"],
+    ["set-option", "-t", UI_SESSION, "status-position", "top"],
+    ["set-option", "-t", UI_SESSION, "status-style", "bg=colour233,fg=colour245"],
+    ["set-option", "-t", UI_SESSION, "status-format[0]", chipStrip(sidebarWidth)],
+    // The window/tab title the terminal app displays — 'synkro', never the
+    // name of whatever process happens to be in the foreground.
+    ["set-option", "-t", UI_SESSION, "set-titles", "on"],
+    ["set-option", "-t", UI_SESSION, "set-titles-string", "synkro"],
+    ["set-option", "-t", UI_SESSION, "pane-border-style", "fg=colour236"],
+    ["set-option", "-t", UI_SESSION, "pane-active-border-style", "fg=colour111"],
+    // Clicking + opens the picker; clicking a name chip selects that tab.
+    // A `range=user|X` reports mouse_status_range as bare X — comparing
+    // against 'user|newtab' silently never matches and the click dead-ends.
+    ["bind-key", "-n", "MouseDown1Status", "if-shell", "-F", "#{==:#{mouse_status_range},newtab}", popup, dispatch],
+    // Right-click anywhere on the strip opens the same tab picker.
+    ["bind-key", "-n", "MouseDown3Status", "display-popup", "-E", "-w", "60", "-h", "18", "-S", "fg=colour111", tabLauncher],
+    // Tab keys without the prefix: Alt+t new tab picker, Alt+arrows move.
+    ["bind-key", "-n", "M-t", "display-popup", "-E", "-w", "80%", "-h", "70%", "-S", "fg=colour111", launcher],
+    ["bind-key", "-n", "M-Right", "next-window"],
+    ["bind-key", "-n", "M-Left", "previous-window"],
+    // Alt+s always returns focus to the sidebar (the leftmost pane).
+    ["bind-key", "-n", "M-s", "select-pane", "-L"]
+  ];
+  for (const argv of style) await run(HOST, ["tmux", ...argv]);
+}
+async function buildTab(bootPath, repoCwd, spec) {
+  let windowTarget;
+  if (!await uiSessionExists()) {
+    const cols = String(Number(process.stdout.columns || 0) || 220);
+    const rows = String(Number(process.stdout.rows || 0) || 55);
+    const create = ["tmux", "new-session", "-d", "-s", UI_SESSION, "-x", cols, "-y", rows, "-c", spec.cwd];
+    if (spec.center) create.push(spec.center);
+    const made = await run(HOST, create);
+    if (!made.ok) {
+      throw new Error("tmux new-session failed: " + made.stderr.trim());
+    }
+    await run(HOST, ["tmux", "set-option", "-t", UI_SESSION, "base-index", "1"]);
+    await run(HOST, ["tmux", "move-window", "-r", "-s", UI_SESSION]);
+    const first = await run(HOST, ["tmux", "list-windows", "-t", UI_SESSION, "-F", "#{window_id}"]);
+    windowTarget = first.stdout.split("\n")[0]?.trim() || UI_SESSION + ":1";
+  } else {
+    const create = ["tmux", "new-window", "-t", UI_SESSION, "-P", "-F", "#{window_id}", "-c", spec.cwd];
+    if (spec.center) create.push(spec.center);
+    const created = await run(HOST, create);
+    windowTarget = created.stdout.trim();
+    if (!created.ok || !windowTarget) return;
+  }
+  const sidebarCols = sidebarColumns(await currentWindowColumns(windowTarget));
+  await styleOuterSession(bootPath, repoCwd, Number(sidebarCols));
+  const split = await run(HOST, [
+    "tmux",
+    "split-window",
+    "-hb",
+    "-t",
+    windowTarget,
+    "-l",
+    sidebarCols,
+    "-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) || "";
+  if (spec.agentSession) {
+    await run(HOST, ["tmux", "set-option", "-t", windowTarget, "-w", "-q", "@synkro_agent", spec.agentSession]);
+  }
+  await run(HOST, ["tmux", "set-option", "-t", windowTarget, "-w", "-q", "@synkro_cwd", spec.cwd]);
+  await run(HOST, ["tmux", "set-option", "-t", windowTarget, "-w", "-q", "@synkro_kind", spec.kind || "terminal"]);
+  await run(HOST, ["tmux", "respawn-pane", "-k", "-t", sidebarPane, sidebarCommand(bootPath, centerPane, repoCwd)]);
+  const title = spec.title || tabTitle("terminal", spec.cwd.split("/").filter(Boolean).pop() || "space");
+  await run(HOST, ["tmux", "set-option", "-t", windowTarget, "-w", "automatic-rename", "off"]);
+  await run(HOST, ["tmux", "rename-window", "-t", windowTarget, title]);
+  await snapshotTabs();
+  await run(HOST, ["tmux", "select-pane", "-t", spec.focus === "sidebar" ? sidebarPane : centerPane]);
+}
+async function snapshotTabs() {
+  const listed = await run(HOST, [
+    "tmux",
+    "list-windows",
+    "-t",
+    UI_SESSION,
+    "-F",
+    ["#{window_name}", "#{@synkro_cwd}", "#{@synkro_kind}", "#{@synkro_agent}"].join("|")
+  ]);
+  if (!listed.ok) return;
+  const tabs = listed.stdout.split("\n").map((line) => line.split("|")).filter((cols) => cols.length >= 4 && cols[1]).map((cols) => ({ title: cols[0], cwd: cols[1], kind: cols[2] || "terminal", agentSession: cols[3] || "" }));
+  if (tabs.length > 0) saveTabs(tabs);
+}
+async function uiSessionExists() {
+  const result = await run(HOST, ["tmux", "has-session", "-t", UI_SESSION]);
+  return result.ok;
+}
+async function launchUi(bootPath, repoCwd) {
+  rememberSpace(repoCwd);
+  if (!await uiSessionExists()) {
+    await buildTab(bootPath, repoCwd, { cwd: repoCwd, center: makeTerminalCommand(bootPath), focus: "sidebar" });
+  }
+  return runInherit(process.env.TMUX ? ["tmux", "switch-client", "-t", UI_SESSION] : ["tmux", "attach-session", "-t", UI_SESSION]);
+}
+var HOST, TAB_GLYPHS;
+var init_launch = __esm({
+  "cli/ui/launch.ts"() {
+    "use strict";
+    init_tmux();
+    init_model();
+    init_manifest();
+    HOST = { kind: "host" };
+    TAB_GLYPHS = {
+      claude: "\u2733",
+      codex: "\u2B21",
+      cursor: "\u27A4",
+      terminal: "\u276F",
+      settings: "\u2699"
+    };
   }
 });
 
@@ -14840,9 +15180,15 @@ var init_consent = __esm({
 function pad(text, width) {
   return text.length >= width ? text.slice(0, width) : text + " ".repeat(width - text.length);
 }
+function clip(text, max) {
+  const value = String(text || "");
+  if (max <= 1) return value.slice(0, Math.max(0, max));
+  return value.length <= max ? value : value.slice(0, max - 1) + "\u2026";
+}
 function row(selected, width, content) {
   const body = stripForPad(" " + content, width);
-  return selected ? STYLE.select + body + STYLE.reset : body;
+  if (!selected) return body;
+  return STYLE.select + body.split(STYLE.reset).join(STYLE.reset + STYLE.select) + STYLE.reset;
 }
 function stripForPad(text, width) {
   let visible = 0;
@@ -14862,49 +15208,143 @@ function stripForPad(text, width) {
   }
   return out + " ".repeat(Math.max(0, width - visible));
 }
-function renderSidebar(state, width = 32, height = 40) {
+function visibleLength(text) {
+  let visible = 0;
+  let index = 0;
+  while (index < text.length) {
+    if (text.startsWith(ESC, index)) {
+      const end = text.indexOf("m", index);
+      if (end === -1) break;
+      index = end + 1;
+    } else {
+      visible += 1;
+      index += 1;
+    }
+  }
+  return visible;
+}
+function splitRow(width, left, right) {
+  const gap = Math.max(1, width - 2 - visibleLength(left) - visibleLength(right));
+  return stripForPad(" " + STYLE.dim + left + STYLE.reset + " ".repeat(gap) + STYLE.header + right + STYLE.reset, width);
+}
+function windowAround(count, selected, capacity) {
+  if (count <= capacity) return { start: 0, end: count };
+  const start = Math.min(Math.max(0, selected - Math.floor(capacity / 2)), count - capacity);
+  return { start, end: start + capacity };
+}
+function renderCollapsed(state, width, height) {
   const lines = [];
-  lines.push("");
-  lines.push(" " + STYLE.header + "spaces" + STYLE.reset);
-  lines.push("");
+  const targets = [];
+  const push2 = (text, target = null) => {
+    lines.push(stripForPad(" " + text, width));
+    targets.push(target);
+  };
+  push2("");
   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));
+    const on = index === state.spaceIndex;
+    const glyph = index < 9 ? String(index + 1) : "+";
+    push2((on ? STYLE.select : "") + (space.backend === "container" ? STYLE.accent : STYLE.bold) + glyph + STYLE.reset, { kind: "space", index });
   });
-  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("");
+  push2(STYLE.dim + "\u2500" + STYLE.reset);
   state.agents.forEach((agent, index) => {
+    const dot = DOT[agent.status] || DOT.idle;
+    const viewing = agent.session === state.viewing && state.viewing !== "";
+    push2((viewing ? STYLE.select : "") + dot, { kind: "agent", index });
+  });
+  push2("");
+  push2(STYLE.dim + "+" + STYLE.reset, { kind: "new" });
+  while (lines.length < height - 1) push2("");
+  push2(STYLE.dim + "\u203A\u203A" + STYLE.reset, { kind: "collapse" });
+  return { lines: lines.slice(0, height), targets: targets.slice(0, height) };
+}
+function renderLayout(state, width = 30, height = 40) {
+  if (state.collapsed) return renderCollapsed(state, width, height);
+  const lines = [];
+  const targets = [];
+  const push2 = (line, target = null) => {
+    lines.push(line);
+    targets.push(target);
+  };
+  const chrome = 8;
+  const listRoom = Math.max(4, height - chrome);
+  const spacesCapacity = Math.max(1, Math.floor(Math.floor(listRoom / 2) / 2));
+  const agentsCapacity = Math.max(1, Math.floor(Math.ceil(listRoom / 2) / 2));
+  const spaceView = windowAround(state.spaces.length, state.spaceIndex, spacesCapacity);
+  const agentView = windowAround(state.agents.length, state.agentIndex, agentsCapacity);
+  push2("");
+  push2(" " + STYLE.header + "sessions" + STYLE.reset);
+  push2("");
+  state.spaces.slice(spaceView.start, spaceView.end).forEach((space, offset) => {
+    const index = spaceView.start + offset;
+    const selected = index === state.spaceIndex;
+    const badge = space.backend === "container" ? STYLE.accent + "\u25A3 " + STYLE.reset : "";
+    const target = { kind: "space", index };
+    push2(row(selected, width, STYLE.done + "\xB7" + STYLE.reset + " " + badge + STYLE.bold + clip(space.name, width - 6) + STYLE.reset), target);
+    const drift = space.track ? " " + STYLE.track + space.track + STYLE.reset : "";
+    push2(row(selected, width, "  " + STYLE.branch + clip(space.branch, width - 6 - (space.track ? space.track.length + 1 : 0)) + STYLE.reset + drift), target);
+  });
+  if (state.spaces.length === 0) push2(row(false, width, STYLE.dim + "no spaces found" + STYLE.reset));
+  while (lines.length < 3 + spacesCapacity * 2) push2(pad("", width));
+  push2("");
+  push2(splitRow(width, "new", "menu"), { kind: "new" });
+  push2(STYLE.dim + "\u2500".repeat(Math.max(0, width)) + STYLE.reset);
+  const blocked = state.agents.filter((agent) => agent.status === "blocked").length;
+  const replied = state.agents.filter((agent) => agent.status === "replied").length;
+  const header = blocked > 0 ? "agents  " + STYLE.blocked + blocked + " waiting" + STYLE.reset : replied > 0 ? "agents  " + STYLE.reply + replied + " replied" + STYLE.reset : "agents";
+  const filterLabel = state.grouped ? "attention" : state.filter === "space" ? state.spaces[state.spaceIndex]?.name || "space" : "all";
+  push2(splitRow(width, header, clip(filterLabel, 12)), { kind: "grouped" });
+  push2("");
+  const ordered = state.grouped ? [...state.agents].sort((a, b) => ATTENTION_ORDER.indexOf(a.status) - ATTENTION_ORDER.indexOf(b.status) || a.name.localeCompare(b.name)) : state.agents;
+  let lastGroup = "";
+  ordered.slice(agentView.start, agentView.end).forEach((agent) => {
+    const index = state.agents.indexOf(agent);
+    if (state.grouped && agent.status !== lastGroup) {
+      lastGroup = agent.status;
+      const label = ATTENTION_LABEL[agent.status] || agent.status;
+      const count = ordered.filter((row2) => row2.status === agent.status).length;
+      push2(row(false, width, (ATTENTION_STYLE[agent.status] || STYLE.dim) + clip(label, width - 8) + STYLE.reset + STYLE.dim + "  " + count + STYLE.reset));
+    }
     const selected = state.section === "agents" && index === state.agentIndex;
+    const isViewing = agent.session === state.viewing && state.viewing !== "";
     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));
+    const target = { kind: "agent", index };
+    const nameStyle = isViewing ? STYLE.accent + STYLE.bold : STYLE.bold;
+    push2(row(selected, width, dot + " " + badge + nameStyle + clip(agent.name, width - 6 - (agent.linear ? agent.linear.length + 2 : 0)) + STYLE.reset + linear), target);
+    const detail = state.grouped ? agent.space ? agent.space.split("/").filter(Boolean).pop() || agent.space : agent.backend : agent.status;
+    const detailStyle = !state.grouped && agent.status === "blocked" ? STYLE.blocked : STYLE.dim;
+    push2(row(selected, width, "  " + detailStyle + clip(detail, width - 8 - agent.harness.length) + STYLE.reset + STYLE.dim + " \xB7 " + agent.harness + STYLE.reset), target);
   });
-  if (state.agents.length === 0) lines.push(row(false, width, STYLE.dim + "no agents \u2014 n to spawn" + STYLE.reset));
+  if (state.agents.length === 0) {
+    push2(row(false, width, STYLE.dim + (state.filter === "space" ? "none in this space \u2014 n to spawn" : "no agents \u2014 n to spawn") + STYLE.reset));
+  }
   const selectedAgent = state.section === "agents" ? state.agents[state.agentIndex] : void 0;
+  if (selectedAgent?.status === "offline") {
+    push2("");
+    push2(row(false, width, STYLE.accent + "\u23FB session offline" + STYLE.reset));
+    push2(row(false, width, STYLE.dim + "  r \u2014 restore, resumes the work" + STYLE.reset));
+  }
   if (selectedAgent?.status === "blocked" && selectedAgent.ask) {
-    lines.push("");
-    lines.push(row(false, width, STYLE.blocked + "\u26D4 needs consent" + STYLE.reset));
+    push2("");
+    push2(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));
+      push2(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");
+  while (lines.length < height - 1) push2(pad("", width));
+  push2(stripForPad(pad("", width - 3) + STYLE.dim + "\u2039\u2039 " + STYLE.reset, width), { kind: "collapse" });
+  return { lines: lines.slice(0, height), targets: targets.slice(0, height) };
+}
+function nextSelection(state, spaces, agents, delta) {
+  const flat = state.section === "spaces" ? state.spaceIndex : spaces + state.agentIndex;
+  const next = Math.min(Math.max(0, flat + delta), Math.max(0, spaces + agents - 1));
+  if (next < spaces) return { section: "spaces", spaceIndex: next, agentIndex: state.agentIndex };
+  if (agents > 0) return { section: "agents", spaceIndex: state.spaceIndex, agentIndex: next - spaces };
+  return { ...state };
 }
-var ESC, STYLE, DOT;
+var ESC, STYLE, ATTENTION_ORDER, ATTENTION_LABEL, ATTENTION_STYLE, DOT;
 var init_render = __esm({
   "cli/ui/render.ts"() {
     "use strict";
@@ -14915,19 +15355,42 @@ var init_render = __esm({
       dim: ESC + "2m",
       bold: ESC + "1m",
       header: ESC + "38;5;245m",
-      select: ESC + "48;5;236m",
+      select: ESC + "48;5;238m",
       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"
+      accent: ESC + "38;5;111m",
+      branch: ESC + "38;5;140m",
+      track: ESC + "38;5;211m",
+      // A finished turn waiting on you: loud enough to catch the eye from across
+      // the screen, distinct from the red of a hard block.
+      reply: ESC + "38;5;155m"
+    };
+    ATTENTION_ORDER = ["blocked", "replied", "idle", "offline", "working", "done"];
+    ATTENTION_LABEL = {
+      blocked: "needs you",
+      replied: "replied",
+      idle: "idle",
+      offline: "offline",
+      working: "working",
+      done: "finished"
+    };
+    ATTENTION_STYLE = {
+      blocked: STYLE.blocked,
+      replied: STYLE.reply,
+      idle: STYLE.header,
+      offline: STYLE.dim,
+      working: STYLE.working,
+      done: STYLE.done
     };
     DOT = {
       working: STYLE.working + "\u25CF" + STYLE.reset,
-      idle: STYLE.idle + "\u25CB" + STYLE.reset,
+      replied: STYLE.reply + "\u25C6" + STYLE.reset,
+      idle: STYLE.idle + "\xB7" + STYLE.reset,
       blocked: STYLE.blocked + "\u25CF" + STYLE.reset,
-      done: STYLE.done + "\u25CF" + STYLE.reset
+      done: STYLE.done + "\u25CF" + STYLE.reset,
+      offline: STYLE.dim + "\u25CB" + STYLE.reset
     };
   }
 });
@@ -14963,225 +15426,1600 @@ async function releaseAgent(runner, pueueId) {
   await run(runner, buildRemove(pueueId)).catch?.(() => {
   });
 }
-var PUEUE_GROUP;
-var init_pueue2 = __esm({
-  "cli/ui/pueue.ts"() {
+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 detectHarnesses() {
+  const probe = await run({ kind: "host" }, [
+    "sh",
+    "-c",
+    'for c in claude codex cursor-agent; do command -v "$c" >/dev/null 2>&1 && echo "$c"; done'
+  ]);
+  const found = new Set(probe.stdout.split("\n").map((line) => line.trim()));
+  const available = [];
+  if (found.has("claude")) available.push("claude");
+  if (found.has("codex")) available.push("codex");
+  if (found.has("cursor-agent")) available.push("cursor");
+  return available;
+}
+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.resume ? resumeCommand(request.harness) : HARNESS_COMMANDS[request.harness] || "claude";
+  for (const argv of buildSpawnAgent({ name: slug, cwd, command, harness: request.harness, space: cwd, backend: request.backend })) {
+    const result = await run(runner, argv);
+    if (!result.ok && argv[1] === "new-session") {
+      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));
+  recordSession({
+    session,
+    name: slug,
+    harness: request.harness,
+    space: cwd,
+    spaceName: request.spaceName,
+    backend: request.backend
+  });
+  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);
+  forgetSession(session);
+}
+var CONTAINER_NAME2, CONTAINER_WORK, AUTH_SEED, HARNESS_COMMANDS;
+var init_backend = __esm({
+  "cli/ui/backend.ts"() {
+    "use strict";
+    init_tmux();
+    init_pueue2();
+    init_manifest();
+    CONTAINER_NAME2 = "synkro-server";
+    CONTAINER_WORK = "/home/synkro/work";
+    AUTH_SEED = CONTAINER_WORK + "/claude-1/.claude.json";
+    HARNESS_COMMANDS = {
+      claude: "claude",
+      codex: "codex",
+      cursor: "cursor-agent"
+    };
+  }
+});
+
+// cli/ui/awake.ts
+import { spawn as spawn8 } from "child_process";
+import { existsSync as existsSync35, mkdirSync as mkdirSync23, readFileSync as readFileSync32, rmSync as rmSync6, writeFileSync as writeFileSync26 } from "fs";
+import { homedir as homedir35, platform as platform5 } from "os";
+import { dirname as dirname11, join as join35 } from "path";
+function shouldStayAwake(agents) {
+  return agents.some((agent) => agent.status === "working");
+}
+function awakeCommand(os = platform5()) {
+  if (os === "darwin") return ["caffeinate", "-i", "-s"];
+  if (os === "linux") {
+    return ["systemd-inhibit", "--what=idle:sleep", "--who=synkro", "--why=agent session running", "sleep", "infinity"];
+  }
+  return null;
+}
+function livePid() {
+  try {
+    const pid = Number(readFileSync32(PIDFILE, "utf8").trim());
+    if (!pid) return 0;
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return 0;
+  }
+}
+function release() {
+  const pid = livePid();
+  if (pid) {
+    try {
+      process.kill(pid);
+    } catch {
+    }
+  }
+  try {
+    if (existsSync35(PIDFILE)) rmSync6(PIDFILE);
+  } catch {
+  }
+}
+function hold() {
+  if (livePid()) return;
+  const command = awakeCommand();
+  if (!command) return;
+  try {
+    const child = spawn8(command[0], command.slice(1), { detached: true, stdio: "ignore" });
+    child.unref();
+    if (!child.pid) return;
+    mkdirSync23(dirname11(PIDFILE), { recursive: true });
+    writeFileSync26(PIDFILE, String(child.pid));
+  } catch {
+  }
+}
+function syncAwake(active, now = Date.now()) {
+  if (active) {
+    lastActive = now;
+    hold();
+    return true;
+  }
+  if (lastActive > 0 && now - lastActive < GRACE_MS) return livePid() > 0;
+  lastActive = 0;
+  release();
+  return false;
+}
+function releaseAwake() {
+  release();
+}
+var PIDFILE, GRACE_MS, lastActive;
+var init_awake = __esm({
+  "cli/ui/awake.ts"() {
+    "use strict";
+    PIDFILE = join35(homedir35(), ".synkro", "ui-awake.pid");
+    GRACE_MS = 9e4;
+    lastActive = 0;
+  }
+});
+
+// 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 ownPane = process.env.TMUX_PANE || "";
+  const [info, harnesses] = await Promise.all([detectContainerBackend(), detectHarnesses()]);
+  const state = {
+    spaces: [],
+    agents: [],
+    section: "spaces",
+    spaceIndex: 0,
+    agentIndex: 0,
+    grouped: false,
+    filter: "space",
+    viewing: "",
+    awake: false,
+    collapsed: false,
+    backendNote: info.note,
+    message: ""
+  };
+  const COLLAPSED_COLS = 4;
+  let allAgents = [];
+  const repoCache = /* @__PURE__ */ new Map();
+  async function agentRepo(path) {
+    if (!path) return "";
+    const cached5 = repoCache.get(path);
+    if (cached5 !== void 0) return cached5;
+    const root = await repoOf(path);
+    repoCache.set(path, root);
+    return root;
+  }
+  function applyFilter() {
+    state.agents = visibleAgents(allAgents, state.spaces[state.spaceIndex], state.filter, state.grouped);
+    state.agentIndex = Math.min(state.agentIndex, Math.max(0, state.agents.length - 1));
+  }
+  let memory = /* @__PURE__ */ new Map();
+  let lastFrame = "";
+  let lastTargets = [];
+  let worldChanged = false;
+  let boundSpace = false;
+  const host = { kind: "host" };
+  const containerRunner = { kind: "container", container: CONTAINER_NAME2 };
+  async function refresh() {
+    const [hostSpaces, conductorTasks] = await Promise.all([
+      discoverHostSpaces(repoCwd),
+      fetchConductorTasks(CONDUCTOR_URL)
+    ]);
+    state.spaces = hostSpaces;
+    const hostAgents = await discoverAgents(host, "host", memory);
+    const containerAgents = info.backend === "container" ? await discoverAgents(containerRunner, "container", memory) : { agents: [], memory: /* @__PURE__ */ new Map() };
+    memory = new Map([...hostAgents.memory, ...containerAgents.memory]);
+    const live = [...hostAgents.agents, ...containerAgents.agents];
+    const merged = [...live, ...offlineAgents(live, loadRecords())];
+    allAgents = await Promise.all(merged.map(async (agent) => ({
+      ...agent,
+      repo: await agentRepo(agent.space),
+      linear: mapAgentToTask(agent.space, conductorTasks)
+    })));
+    const shown = await run(host, ["tmux", "display-message", "-p", "-t", ownPane, "#{@synkro_agent}#{l:|}#{@synkro_cwd}"]);
+    const parts = (shown.ok ? shown.stdout.trim() : "").split("|");
+    state.viewing = parts[0] || "";
+    if (!boundSpace && state.spaces.length > 0 && parts[1]) {
+      const tabRepo = await agentRepo(parts[1]);
+      const index = state.spaces.findIndex((space) => space.path === tabRepo);
+      if (index >= 0) state.spaceIndex = index;
+      boundSpace = true;
+    }
+    state.spaceIndex = Math.min(state.spaceIndex, Math.max(0, state.spaces.length - 1));
+    applyFilter();
+    state.awake = syncAwake(shouldStayAwake(allAgents));
+  }
+  function draw() {
+    const rows = Number(process.stdout.rows || 42);
+    const cols = Number(process.stdout.columns || 30);
+    const layout = renderLayout(state, cols, rows);
+    const frame = layout.lines.join("\n");
+    lastTargets = layout.targets;
+    if (frame === lastFrame) return;
+    lastFrame = frame;
+    process.stdout.write(CSI + "H" + frame);
+  }
+  function forceDraw() {
+    lastFrame = "";
+    draw();
+  }
+  let stripWidth = -1;
+  async function syncChipStrip() {
+    const asked = await run(host, ["tmux", "display-message", "-p", "-t", outerSession, "#{window_width}"]);
+    const windowWidth = Number(asked.stdout.trim()) || Number(process.stdout.columns || 0);
+    if (windowWidth <= 0) return;
+    const target = state.collapsed ? COLLAPSED_COLS : Number(sidebarColumns(windowWidth));
+    if (ownPane && Number(process.stdout.columns || 0) !== target) {
+      await run(host, ["tmux", "resize-pane", "-t", ownPane, "-x", String(target)]);
+    }
+    if (target === stripWidth) return;
+    stripWidth = target;
+    await run(host, ["tmux", "set-option", "-t", outerSession, "status-format[0]", chipStrip(target)]);
+  }
+  async function setCollapsed(next) {
+    if (state.collapsed === next) return;
+    state.collapsed = next;
+    stripWidth = -1;
+    await run(host, ["tmux", "set-option", "-t", outerSession, "-q", "@synkro_collapsed", next ? "1" : "0"]);
+    await syncChipStrip();
+    redrawAfterResize();
+  }
+  async function toggleCollapsed() {
+    await setCollapsed(!state.collapsed);
+  }
+  async function syncCollapsed() {
+    const opt = await run(host, ["tmux", "show-options", "-t", outerSession, "-v", "@synkro_collapsed"]);
+    await setCollapsed(opt.stdout.trim() === "1");
+  }
+  function redrawAfterResize() {
+    process.stdout.write(CSI + "2J");
+    forceDraw();
+    void syncChipStrip();
+  }
+  async function attachedClient() {
+    const listed = await run(host, ["tmux", "list-clients", "-t", outerSession, "-F", "#{client_name}"]);
+    return listed.stdout.split("\n").map((line) => line.trim()).filter(Boolean)[0] || "";
+  }
+  function selectedSpace() {
+    return state.spaces[state.spaceIndex] || state.spaces[0];
+  }
+  async function openDialog(kind, args2 = []) {
+    const client = await attachedClient();
+    if (!client) {
+      state.message = "no attached client";
+      return;
+    }
+    const cwd = selectedSpace()?.path || repoCwd;
+    const opened = await run(host, buildDialogPopup({
+      client,
+      bootPath,
+      kind,
+      cwd,
+      args: args2,
+      width: "80%",
+      height: "70%"
+    }));
+    if (!opened.ok) state.message = "dialog failed";
+    worldChanged = true;
+  }
+  async function mainMenu() {
+    await openDialog("menu", [outerSession, ownPane]);
+  }
+  function closeSelectedWorkspace() {
+    const space = selectedSpace();
+    if (!space || space.backend !== "host") return;
+    forgetSpace(space.path);
+    state.message = "closed " + space.name;
+  }
+  async function keybindsMenu() {
+    await openDialog("keybinds");
+  }
+  async function restoreSelected() {
+    const agent = state.agents[state.agentIndex];
+    if (!agent || agent.status !== "offline") return;
+    state.message = "restoring " + agent.name + "\u2026";
+    forceDraw();
+    const restored = await run(host, ["node", bootPath, "ui", "--restore", agent.session]);
+    state.message = restored.ok ? "restored " + agent.name : "restore failed";
+  }
+  async function attachSelected() {
+    const agent = state.agents[state.agentIndex];
+    if (agent) await showAgent(agent);
+  }
+  async function showAgent(agent) {
+    if (!centerPane) return;
+    if (agent.status === "offline") {
+      await restoreSelected();
+      return;
+    }
+    const current = memory.get(agent.session);
+    memory.set(agent.session, { hash: current?.hash || "", wasWorking: false, seen: true });
+    if (agent.space) rememberLastAgent(await repoOf(agent.space), agent.session);
+    state.viewing = agent.session;
+    const windows = await run(host, ["tmux", "list-windows", "-t", outerSession, "-F", "#{window_id}|#{@synkro_agent}"]);
+    const holder = windows.stdout.split("\n").map((line) => line.split("|")).find((cols) => cols[1] === agent.session);
+    if (holder) {
+      await run(host, ["tmux", "select-window", "-t", holder[0]]);
+      state.message = agent.name;
+      return;
+    }
+    await run(runnerFor(agent.backend), buildEnableMouse(agent.session));
+    const command = buildCenterAttachCommand(runnerFor(agent.backend), agent.session);
+    await run(host, ["tmux", "respawn-pane", "-k", "-t", centerPane, command]);
+    const where = agent.space ? agent.space.split("/").filter(Boolean).pop() || "" : "";
+    await run(host, ["tmux", "rename-window", "-t", centerPane, tabTitle(agent.harness, where)]);
+    await run(host, ["tmux", "set-option", "-t", centerPane, "-w", "-q", "@synkro_agent", agent.session]);
+    await run(host, ["tmux", "set-option", "-t", centerPane, "-w", "-q", "@synkro_kind", agent.harness]);
+    await snapshotTabs();
+    state.message = "attached " + agent.name;
+  }
+  async function confirmKillAgent() {
+    const agent = state.agents[state.agentIndex];
+    if (!agent) return;
+    await openDialog("kill", [agent.backend, agent.session]);
+  }
+  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;
+  }
+  function moveSelection(delta) {
+    Object.assign(state, nextSelection(state, state.spaces.length, state.agents.length, delta));
+    applyFilter();
+  }
+  async function activate(target) {
+    if (target.kind === "space") {
+      state.section = "spaces";
+      state.spaceIndex = target.index;
+      applyFilter();
+      const space = state.spaces[target.index];
+      const remembered = space ? lastAgentFor(space.path) : "";
+      const agent = allAgents.find((row2) => row2.session === remembered && row2.status !== "offline");
+      if (agent) await showAgent(agent);
+    } else if (target.kind === "agent") {
+      state.section = "agents";
+      state.agentIndex = target.index;
+      await attachSelected();
+    } else if (target.kind === "new") await openDialog("new-tab");
+    else if (target.kind === "menu") await mainMenu();
+    else if (target.kind === "grouped") {
+      state.filter = state.filter === "space" ? "all" : "space";
+      applyFilter();
+    } else if (target.kind === "collapse") await toggleCollapsed();
+  }
+  async function handleClick(x, y, rightButton) {
+    const target = lastTargets[y - 1];
+    if (!target) return;
+    const cols = Number(process.stdout.columns || 30);
+    if (target.kind === "new") {
+      await (x > cols / 2 ? mainMenu() : openDialog("new-tab"));
+      return;
+    }
+    if (target.kind === "grouped") {
+      if (x > cols / 2) {
+        state.filter = state.filter === "space" ? "all" : "space";
+        applyFilter();
+      }
+      return;
+    }
+    if (rightButton) {
+      if (target.kind === "space") {
+        state.section = "spaces";
+        state.spaceIndex = target.index;
+        await openDialog("new-tab");
+      }
+      if (target.kind === "agent") {
+        state.section = "agents";
+        state.agentIndex = target.index;
+        await confirmKillAgent();
+      }
+      return;
+    }
+    await activate(target);
+  }
+  async function handleKey(key) {
+    if (key === "	") state.section = state.section === "spaces" ? "agents" : "spaces";
+    else if (key === "j" || key === CSI + "B") moveSelection(1);
+    else if (key === "k" || key === CSI + "A") moveSelection(-1);
+    else if (key === "\r") {
+      if (state.section === "agents") await attachSelected();
+      else await openDialog("new-tab");
+    } else if (key === "n" || key === "T") {
+      worldChanged = true;
+      await openDialog("new-tab");
+    } else if (key === "m") await mainMenu();
+    else if (key === "O") void openDialog("new-workspace");
+    else if (key === "C") {
+      worldChanged = true;
+      closeSelectedWorkspace();
+    } else if (key === "r") {
+      worldChanged = true;
+      await restoreSelected();
+    } else if (key === "d") {
+      const client = await attachedClient();
+      await run(host, client ? ["tmux", "detach-client", "-t", client] : ["tmux", "detach-client"]);
+    } else if (key === "K") await keybindsMenu();
+    else if (key === "G") {
+      state.grouped = !state.grouped;
+      applyFilter();
+    } else if (key === "a") {
+      state.filter = state.filter === "space" ? "all" : "space";
+      applyFilter();
+    } else if (key === "<" || key === ">" || key === "," || key === ".") await toggleCollapsed();
+    else if (key === "x") {
+      worldChanged = true;
+      await confirmKillAgent();
+    } 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 === "q" || key === KEY_CTRL_C) {
+      await snapshotTabs();
+      releaseAwake();
+      await run(host, ["tmux", "kill-session", "-t", outerSession]);
+      process.exit(0);
+    }
+  }
+  process.stdout.on("resize", redrawAfterResize);
+  process.stdin.setRawMode?.(true);
+  process.stdin.resume();
+  process.stdout.write(CSI + "?1000h" + CSI + "?1006h");
+  process.on("exit", () => process.stdout.write(CSI + "?1000l" + CSI + "?1006l"));
+  let refreshing = false;
+  async function refreshSafe() {
+    if (refreshing) return;
+    refreshing = true;
+    try {
+      await refresh();
+    } finally {
+      refreshing = false;
+    }
+  }
+  const MOUSE = /\[<(\d+);(\d+);(\d+)([Mm])/g;
+  process.stdin.on("data", (chunk) => {
+    const input = chunk.toString("utf8");
+    void (async () => {
+      let sawMouse = false;
+      let event;
+      MOUSE.lastIndex = 0;
+      while ((event = MOUSE.exec(input)) !== null) {
+        sawMouse = true;
+        const button = Number(event[1]);
+        const x = Number(event[2]);
+        const y = Number(event[3]);
+        if (event[4] !== "M") continue;
+        if (button === 0 || button === 2) await handleClick(x, y, button === 2);
+      }
+      if (!sawMouse) await handleKey(input);
+      forceDraw();
+      if (worldChanged) {
+        worldChanged = false;
+        void refreshSafe().then(draw);
+      }
+    })();
+  });
+  await refreshSafe();
+  redrawAfterResize();
+  await syncChipStrip();
+  setInterval(() => {
+    void syncCollapsed();
+    void syncChipStrip();
+    void refreshSafe().then(draw);
+  }, POLL_MS);
+}
+var POLL_MS, CONDUCTOR_URL, CSI, KEY_CTRL_C;
+var init_sidebar = __esm({
+  "cli/ui/sidebar.ts"() {
+    "use strict";
+    init_model();
+    init_manifest();
+    init_render();
+    init_consent();
+    init_backend();
+    init_tmux();
+    init_launch();
+    init_awake();
+    POLL_MS = 2e3;
+    CONDUCTOR_URL = "http://127.0.0.1:" + (process.env.SYNKRO_HOST_MCP_PORT || "18931");
+    CSI = "\x1B[";
+    KEY_CTRL_C = "";
+  }
+});
+
+// cli/ui/repos.ts
+import { existsSync as existsSync36, readdirSync as readdirSync9 } from "fs";
+import { homedir as homedir36 } from "os";
+import { join as join36 } from "path";
+function isRepo(path) {
+  return existsSync36(join36(path, ".git"));
+}
+function childDirectories(path) {
+  try {
+    return readdirSync9(path, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !SKIP.has(entry.name) && !entry.name.startsWith(".")).map((entry) => join36(path, entry.name));
+  } catch {
+    return [];
+  }
+}
+function discoverRepos(extra = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const choices = [];
+  const add = (path, note) => {
+    const clean = path.replace(/\/+$/, "");
+    if (!clean || seen.has(clean) || !isRepo(clean)) return;
+    seen.add(clean);
+    choices.push({ path: clean, name: clean.split("/").filter(Boolean).pop() || clean, note });
+  };
+  for (const path of extra) add(path, "current");
+  for (const path of loadRepos()) add(path, "recent");
+  const home = homedir36();
+  for (const root of SCAN_ROOTS) {
+    const base = root ? join36(home, root) : home;
+    if (!existsSync36(base)) continue;
+    if (isRepo(base)) {
+      add(base, "");
+      continue;
+    }
+    for (const child of childDirectories(base)) add(child, "");
+  }
+  return choices;
+}
+var SCAN_ROOTS, SKIP;
+var init_repos = __esm({
+  "cli/ui/repos.ts"() {
+    "use strict";
+    init_manifest();
+    SCAN_ROOTS = ["", "code", "src", "dev", "projects", "work", "repos", "git", "Developer", "Documents/GitHub"];
+    SKIP = /* @__PURE__ */ new Set(["node_modules", "Library", "Applications", ".Trash", ".git"]);
+  }
+});
+
+// cli/ui/tabs.ts
+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();
+  }
+}
+async function createTab(bootPath, kind, spacePath) {
+  const repo = repoRoot();
+  const space = spacePath.split("/").filter(Boolean).pop() || "space";
+  if (kind === "terminal") {
+    await buildTab(bootPath, repo, {
+      cwd: spacePath,
+      center: makeTerminalCommand(bootPath),
+      title: tabTitle("terminal", space),
+      kind: "terminal",
+      focus: "center"
+    });
+    return;
+  }
+  if (kind === "cursor-synkro") {
+    await buildTab(bootPath, repo, {
+      cwd: spacePath,
+      center: ["node", bootPath, "ui", "--run", "cursor", spacePath].map(shellQuote3).join(" "),
+      title: tabTitle("cursor", space),
+      kind: "cursor-synkro",
+      focus: "center"
+    });
+    return;
+  }
+  if (kind === "settings") {
+    await buildTab(bootPath, repo, {
+      cwd: spacePath,
+      center: "sh -c " + shellQuote3('exec "${EDITOR:-vi}" synkro.toml'),
+      title: tabTitle("settings", "settings"),
+      kind: "settings",
+      focus: "center"
+    });
+    return;
+  }
+  const info = await detectContainerBackend();
+  const spaceName = space;
+  const stamp = String(process.pid % 1e4);
+  const harness = ["claude", "codex", "cursor"].includes(kind) ? kind : "claude";
+  const reachable = info.backend === "container" && (await run(info.runner, ["test", "-d", spacePath])).ok;
+  const backend = reachable ? "container" : "host";
+  const spawned = await spawnAgent(info, {
+    name: spaceName + "-" + harness + "-" + stamp,
+    harness,
+    spaceName,
+    cwd: spacePath,
+    backend
+  });
+  if (!spawned.ok) return;
+  await buildTab(bootPath, repo, {
+    cwd: spacePath,
+    center: buildCenterAttachCommand(backend === "container" ? info.runner : HOST2, spawned.session),
+    title: tabTitle(harness, spaceName),
+    kind: harness,
+    agentSession: spawned.session,
+    focus: "center"
+  });
+}
+async function openAgentTab(bootPath, session) {
+  if (!session.startsWith("synkro-agent-")) return;
+  const info = await detectContainerBackend();
+  const meta = await run(HOST2, [
+    "tmux",
+    "display-message",
+    "-p",
+    "-t",
+    session,
+    ["#{@synkro_harness}", "#{@synkro_space}", "#{@synkro_backend}"].join("|")
+  ]);
+  const [harness, space, backend] = (meta.stdout.trim() || "||").split("|");
+  const containerHosted = backend === "container";
+  const runner = containerHosted ? info.runner : HOST2;
+  const alive = (await run(runner, ["tmux", "has-session", "-t", session])).ok;
+  if (!alive) return;
+  const spaceName = (space || "").split("/").filter(Boolean).pop() || "space";
+  await buildTab(bootPath, repoRoot(), {
+    cwd: space || repoRoot(),
+    center: buildCenterAttachCommand(runner, session),
+    title: tabTitle(harness || "claude", spaceName),
+    kind: harness || "claude",
+    agentSession: session,
+    focus: "center"
+  });
+}
+async function restoreTabs(bootPath, repoCwd) {
+  const tabs = loadTabs();
+  if (tabs.length === 0) return false;
+  const info = await detectContainerBackend();
+  const hostSessions = (await run(HOST2, ["tmux", "list-sessions", "-F", "#{session_name}"])).stdout;
+  const containerSessions = info.backend === "container" ? (await run(info.runner, ["tmux", "list-sessions", "-F", "#{session_name}"])).stdout : "";
+  const alive = new Set((hostSessions + "\n" + containerSessions).split("\n").map((line) => line.trim()).filter(Boolean));
+  let built = false;
+  for (const tab of tabs) {
+    const space = tab.cwd.split("/").filter(Boolean).pop() || "space";
+    const containerHosted = info.backend === "container" && (await run(info.runner, ["test", "-d", tab.cwd])).ok;
+    const harness = ["claude", "codex", "cursor"].includes(tab.kind) ? tab.kind : "";
+    if (tab.agentSession && alive.has(tab.agentSession)) {
+      await run(containerHosted ? info.runner : HOST2, buildEnableMouse(tab.agentSession));
+      await buildTab(bootPath, repoCwd, {
+        cwd: tab.cwd,
+        center: buildCenterAttachCommand(containerHosted ? info.runner : HOST2, tab.agentSession),
+        title: tab.title,
+        kind: tab.kind,
+        agentSession: tab.agentSession,
+        focus: "center"
+      });
+    } else if (harness) {
+      const spawned = await spawnAgent(info, {
+        name: space + "-" + harness + "-" + String(process.pid % 1e4),
+        harness,
+        spaceName: space,
+        cwd: tab.cwd,
+        backend: containerHosted ? "container" : "host",
+        resume: true
+      });
+      await buildTab(bootPath, repoCwd, spawned.ok ? {
+        cwd: tab.cwd,
+        center: buildCenterAttachCommand(containerHosted ? info.runner : HOST2, spawned.session),
+        title: tabTitle(harness, space),
+        kind: harness,
+        agentSession: spawned.session,
+        focus: "center"
+      } : { cwd: tab.cwd, center: makeTerminalCommand(bootPath), title: tabTitle("terminal", space), kind: "terminal", focus: "center" });
+    } else {
+      await buildTab(bootPath, repoCwd, {
+        cwd: tab.cwd,
+        center: makeTerminalCommand(bootPath),
+        title: tabTitle("terminal", space),
+        kind: "terminal",
+        focus: "center"
+      });
+    }
+    built = true;
+  }
+  return built;
+}
+var HOST2;
+var init_tabs = __esm({
+  "cli/ui/tabs.ts"() {
+    "use strict";
+    init_launch();
+    init_backend();
+    init_manifest();
+    init_tmux();
+    HOST2 = { kind: "host" };
+  }
+});
+
+// cli/ui/dialog.ts
+import { existsSync as existsSync37 } from "fs";
+import { homedir as homedir37 } from "os";
+function write(text) {
+  process.stdout.write(text);
+}
+function visibleLength2(text) {
+  let visible = 0;
+  let index = 0;
+  while (index < text.length) {
+    if (text.startsWith(CSI2, index)) {
+      const end = text.indexOf("m", index);
+      if (end === -1) break;
+      index = end + 1;
+    } else {
+      visible += 1;
+      index += 1;
+    }
+  }
+  return visible;
+}
+function clipPath(text, max) {
+  const value = String(text || "");
+  if (max <= 1) return value.slice(0, Math.max(0, max));
+  return value.length <= max ? value : "\u2026" + value.slice(value.length - max + 1);
+}
+function clip2(text, max) {
+  const value = String(text || "");
+  if (max <= 1) return value.slice(0, Math.max(0, max));
+  return value.length <= max ? value : value.slice(0, max - 1) + "\u2026";
+}
+function padRow(text, width) {
+  const gap = Math.max(0, width - visibleLength2(text));
+  return text + " ".repeat(gap);
+}
+function selectable(text, width, selected) {
+  const body = padRow(text, width);
+  if (!selected) return body;
+  return S.select + body.split(S.reset).join(S.reset + S.select) + S.reset;
+}
+function isPrintable(input) {
+  if (!input) return false;
+  for (const char of input) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) return false;
+  }
+  return true;
+}
+function matches(choice, filter) {
+  if (!filter) return true;
+  const needle = filter.toLowerCase();
+  return (choice.label + " " + (choice.detail || "")).toLowerCase().includes(needle);
+}
+async function pick(opts) {
+  let selected = Math.min(Math.max(0, opts.initial || 0), Math.max(0, opts.choices.length - 1));
+  let filter = "";
+  let top = 0;
+  const width = Math.max(20, Number(process.stdout.columns || 80));
+  const height = Math.max(8, Number(process.stdout.rows || 20));
+  const perItem = opts.choices.some((choice) => choice.detail) ? 2 : 1;
+  const visibleItems = Math.max(1, Math.floor(Math.max(2, height - 5) / perItem));
+  const firstRow = 4;
+  return new Promise((resolve7) => {
+    const view = () => opts.choices.filter((choice) => matches(choice, filter));
+    const draw = () => {
+      const shown = view();
+      if (selected >= shown.length) selected = Math.max(0, shown.length - 1);
+      if (selected < top) top = selected;
+      if (selected >= top + visibleItems) top = selected - visibleItems + 1;
+      const lines = [];
+      lines.push(" " + S.title + opts.title + S.reset);
+      const left = filter && !opts.menu ? " " + S.accent + "/ " + S.reset + filter + "\u258C" : " " + S.dim + opts.hint + S.reset;
+      const right = opts.menu ? "" : S.dim + String(shown.length) + (shown.length === 1 ? " match" : " matches") + S.reset;
+      lines.push(padRow(left, Math.max(0, width - visibleLength2(right) - 1)) + right);
+      lines.push("");
+      if (shown.length === 0) lines.push(" " + S.dim + (opts.emptyNote || "nothing matches") + S.reset);
+      shown.slice(top, top + visibleItems).forEach((choice, offset) => {
+        const index = top + offset;
+        const isSelected = index === selected;
+        const marker = isSelected ? S.accent + "\u203A" + S.reset + " " : "  ";
+        const note = choice.note ? S.dim + choice.note + S.reset : "";
+        const head = " " + marker + S.bold + clip2(choice.label, width - 6 - visibleLength2(note)) + S.reset;
+        lines.push(selectable(padRow(head, Math.max(0, width - visibleLength2(note) - 1)) + note, width, isSelected));
+        if (perItem === 2) {
+          lines.push(selectable("    " + S.muted + clipPath(choice.detail || "", width - 6) + S.reset, width, isSelected));
+        }
+      });
+      while (lines.length < height - 1) lines.push("");
+      lines.push(" " + S.dim + opts.footer + S.reset);
+      write(CSI2 + "H" + lines.slice(0, height).map((line) => padRow(line, width)).join("\n"));
+    };
+    const rowOfItem = (index) => firstRow + (index - top) * perItem;
+    const MOUSE = /\[<(\d+);(\d+);(\d+)([Mm])/g;
+    const onData = (chunk) => {
+      const input = chunk.toString("utf8");
+      const shown = view();
+      let sawMouse = false;
+      let event;
+      MOUSE.lastIndex = 0;
+      while ((event = MOUSE.exec(input)) !== null) {
+        sawMouse = true;
+        if (event[4] !== "M") continue;
+        const button = Number(event[1]);
+        const y = Number(event[3]);
+        if (button === 64) selected = Math.max(0, selected - 1);
+        else if (button === 65) selected = Math.min(shown.length - 1, selected + 1);
+        else if (button === 0) {
+          const hit = shown.findIndex((_, index) => y >= rowOfItem(index) && y < rowOfItem(index) + perItem);
+          if (hit >= 0) {
+            process.stdin.off("data", onData);
+            resolve7(shown[hit].value);
+            return;
+          }
+        }
+      }
+      if (!sawMouse) {
+        if (input === KEY_ESC && !input.includes("[<") || input === KEY_CTRL_C2) {
+          process.stdin.off("data", onData);
+          resolve7(null);
+          return;
+        }
+        if (input === "\r") {
+          if (shown.length === 0) return;
+          process.stdin.off("data", onData);
+          resolve7(shown[selected].value);
+          return;
+        }
+        const down = input === CSI2 + "B" || opts.menu && (input === "j" || input === CSI2 + "C");
+        const up = input === CSI2 + "A" || opts.menu && (input === "k" || input === CSI2 + "D");
+        if (down) selected = Math.min(shown.length - 1, selected + 1);
+        else if (up) selected = Math.max(0, selected - 1);
+        else if (!opts.menu && (input === KEY_BACKSPACE || input === "\b")) filter = filter.slice(0, -1);
+        else if (!opts.menu && isPrintable(input)) {
+          filter += input;
+          selected = 0;
+          top = 0;
+        }
+      }
+      draw();
+    };
+    process.stdin.on("data", onData);
+    draw();
+  });
+}
+async function readLine(opts) {
+  let value = "";
+  let error = "";
+  const width = Math.max(20, Number(process.stdout.columns || 80));
+  return new Promise((resolve7) => {
+    const draw = () => {
+      const lines = [
+        " " + S.title + opts.title + S.reset,
+        "",
+        " " + S.dim + opts.label + S.reset,
+        "",
+        " " + S.accent + "> " + S.reset + value + "\u258C",
+        "",
+        error ? " " + S.error + error + S.reset : "",
+        "",
+        " " + S.dim + opts.footer + S.reset
+      ];
+      write(CSI2 + "2J" + CSI2 + "H" + lines.map((line) => padRow(line, width)).join("\n"));
+    };
+    const onData = (chunk) => {
+      const input = chunk.toString("utf8");
+      if (input === KEY_ESC || input === KEY_CTRL_C2) {
+        process.stdin.off("data", onData);
+        resolve7(null);
+        return;
+      }
+      if (input === "\r") {
+        void (async () => {
+          const problem = await opts.validate(value.trim());
+          if (problem) {
+            error = problem.slice(0, width - 4);
+            draw();
+            return;
+          }
+          process.stdin.off("data", onData);
+          resolve7(value.trim());
+        })();
+        return;
+      }
+      if (input === KEY_BACKSPACE || input === "\b") value = value.slice(0, -1);
+      else if (isPrintable(input)) value += input;
+      draw();
+    };
+    process.stdin.on("data", onData);
+    draw();
+  });
+}
+async function pickRepo(repoCwd) {
+  const current = canonicalSpacePath(repoCwd);
+  const choices = discoverRepos(current ? [current] : []).map((repo) => ({
+    value: repo.path,
+    label: repo.name,
+    detail: repo.path,
+    note: repo.note
+  }));
+  choices.push({ value: TYPE_PATH, label: "other path\u2026", detail: "type a repository path" });
+  const picked = await pick({
+    title: "open repository",
+    hint: "type to filter repositories",
+    choices,
+    footer: "\u2191\u2193 select   \u21B5 next   esc close",
+    emptyNote: 'no repositories found \u2014 choose "other path\u2026"'
+  });
+  if (!picked) return null;
+  if (picked !== TYPE_PATH) return picked;
+  let resolved = null;
+  await readLine({
+    title: "open repository",
+    label: "repository path",
+    footer: "\u21B5 open   esc back",
+    validate: async (value) => {
+      const path = value.replace(/^~(?=\/|$)/, homedir37()).replace(/\/+$/, "");
+      if (!path || !existsSync37(path + "/.git")) return "not a git repository: " + path.slice(-40);
+      resolved = path;
+      return null;
+    }
+  });
+  return resolved;
+}
+async function pickWorktree(repoPath) {
+  const worktrees = await listWorktrees(repoPath);
+  const choices = worktrees.map((worktree) => ({
+    value: worktree.path,
+    label: worktree.branch || worktree.path.split("/").filter(Boolean).pop() || worktree.path,
+    detail: worktree.path,
+    note: worktree.note
+  }));
+  choices.push({ value: NEW_WORKTREE, label: "+ new worktree\u2026", detail: "branch off this repository" });
+  const picked = await pick({
+    title: "open worktree \u2014 " + (repoPath.split("/").filter(Boolean).pop() || repoPath),
+    hint: "type to filter worktrees",
+    choices,
+    footer: "\u2191\u2193 select   \u21B5 open   esc back"
+  });
+  if (!picked) return null;
+  if (picked !== NEW_WORKTREE) return picked;
+  let created = null;
+  await readLine({
+    title: "new worktree",
+    label: "branch name",
+    footer: "\u21B5 create   esc back",
+    validate: async (branch) => {
+      if (!SAFE_BRANCH.test(branch)) return "letters, digits, . _ - / only";
+      const target = repoPath.replace(/\/+$/, "") + "-" + branch.replace(/\//g, "-");
+      const fresh = await run({ kind: "host" }, ["git", "-C", repoPath, "worktree", "add", "-b", branch, target]);
+      const made = fresh.ok ? fresh : await run({ kind: "host" }, ["git", "-C", repoPath, "worktree", "add", target, branch]);
+      if (!made.ok) return made.stderr.trim() || "git refused";
+      created = target;
+      return null;
+    }
+  });
+  return created;
+}
+async function runMenu(bootPath, repoCwd, outerSession, sidebarPane) {
+  const choice = await pick({
+    menu: true,
+    title: "synkro",
+    hint: "choose an action",
+    choices: [
+      { value: "workspace", label: "Open workspace\u2026" },
+      { value: "settings", label: "Settings" },
+      { value: "keybinds", label: "Keybinds" },
+      { value: "reload", label: "Reload sidebar" },
+      { value: "detach", label: "Detach  (everything keeps running)" },
+      { value: "quit", label: "Quit synkro ui  (agents keep running)" }
+    ],
+    footer: "\u2191\u2193 select   \u21B5 choose   esc close"
+  });
+  if (!choice) return;
+  if (choice === "workspace") {
+    const repo = await pickRepo(repoCwd);
+    if (!repo) return;
+    rememberRepo(repo);
+    const worktree = await pickWorktree(repo);
+    if (worktree) rememberSpace(await repoOf(worktree));
+    return;
+  }
+  if (choice === "settings") {
+    await createTab(bootPath, "settings", repoCwd);
+    return;
+  }
+  if (choice === "keybinds") {
+    await runKeybinds();
+    return;
+  }
+  if (choice === "reload" && sidebarPane) {
+    await run({ kind: "host" }, ["tmux", "respawn-pane", "-k", "-t", sidebarPane]);
+    return;
+  }
+  if (choice === "detach") {
+    await run({ kind: "host" }, ["tmux", "detach-client", "-s", outerSession]);
+    return;
+  }
+  if (choice === "quit") await run({ kind: "host" }, ["tmux", "kill-session", "-t", outerSession]);
+}
+async function runKeybinds() {
+  await pick({
+    menu: true,
+    title: "keybinds",
+    hint: "sidebar",
+    choices: [
+      { value: "", label: "\u2191 \u2193      move through spaces and agents" },
+      { value: "", label: "\u21B5 click  open the selected agent" },
+      { value: "", label: "n        new tab in this space" },
+      { value: "", label: "a        all spaces / this space" },
+      { value: "", label: "G        group by what needs you" },
+      { value: "", label: "g s y    consent: track / skip / stay" },
+      { value: "", label: "r        restore an offline session" },
+      { value: "", label: "x        close agent    i  interrupt" },
+      { value: "", label: "\u2325t       new tab       \u2325\u2190\u2192  switch tab" },
+      { value: "", label: "\u2325s       focus sidebar" },
+      { value: "", label: "< >      collapse / expand sidebar" },
+      { value: "", label: "d        detach        q  quit" }
+    ],
+    footer: "esc close"
+  });
+}
+async function runTabMenu(outerSession) {
+  const host = { kind: "host" };
+  const listed = await run(host, [
+    "tmux",
+    "list-windows",
+    "-t",
+    outerSession,
+    "-F",
+    ["#{window_id}", "#{window_index}", "#{window_active}", "#{window_name}", "#{@synkro_agent}"].join("|")
+  ]);
+  const tabs = listed.stdout.split("\n").map((line) => line.split("|")).filter((cols) => cols[0]);
+  if (tabs.length === 0) return;
+  const activeIndex = Math.max(0, tabs.findIndex((cols) => cols[2] === "1"));
+  const chosen = await pick({
+    menu: true,
+    title: "tabs",
+    hint: "pick a tab",
+    initial: activeIndex,
+    choices: tabs.map((cols) => ({
+      value: cols[0],
+      label: (cols[2] === "1" ? "\u203A " : "  ") + (cols[3] || "tab " + cols[1]),
+      detail: cols[4] ? cols[4].replace(/^synkro-agent-/, "") : "terminal"
+    })),
+    footer: "\u2191\u2193 select   \u21B5 choose   esc close"
+  });
+  if (!chosen) return;
+  const tab = tabs.find((cols) => cols[0] === chosen);
+  if (!tab) return;
+  const [windowId, , , name, agentSession2] = tab;
+  const action = await pick({
+    menu: true,
+    title: name || "tab",
+    hint: "what to do with this tab",
+    choices: [
+      { value: "rename", label: "Rename tab\u2026" },
+      { value: "close", label: "Close tab" }
+    ],
+    footer: "\u2191\u2193 select   \u21B5 choose   esc back"
+  });
+  if (!action) return;
+  if (action === "rename") {
+    let renamed = "";
+    await readLine({
+      title: "rename tab",
+      label: "tab name",
+      footer: "\u21B5 save   esc back",
+      validate: async (value) => {
+        if (!value.trim()) return "name cannot be empty";
+        renamed = value.trim();
+        return null;
+      }
+    });
+    if (renamed) {
+      await run(host, ["tmux", "rename-window", "-t", windowId, renamed]);
+      await snapshotTabs();
+    }
+    return;
+  }
+  const confirm = await pick({
+    menu: true,
+    title: "Close " + (name || "this tab") + "?",
+    hint: agentSession2 ? "the agent keeps running \u2014 reopen it from the sidebar" : "a terminal tab, nothing else is affected",
+    choices: [
+      { value: "no", label: "Cancel" },
+      { value: "yes", label: "Close tab" }
+    ],
+    footer: "\u2191\u2193 select   \u21B5 choose   esc cancel"
+  });
+  if (confirm !== "yes") return;
+  await run(host, ["tmux", "kill-window", "-t", windowId]);
+  await snapshotTabs();
+}
+async function runKillConfirm(backend, session) {
+  const name = session.replace(/^synkro-agent-/, "");
+  const choice = await pick({
+    menu: true,
+    title: "Close agent?",
+    hint: name,
+    choices: [
+      { value: "no", label: "Cancel" },
+      { value: "yes", label: "Close it  (its work is not saved anywhere else)" }
+    ],
+    footer: "\u2191\u2193 select   \u21B5 choose   esc cancel"
+  });
+  if (choice !== "yes") return;
+  await killAgent(backend === "container" ? "container" : "host", session, "");
+}
+async function runDialog(kind, repoCwd, argA = "", argB = "") {
+  const bootPath = String(process.argv[1] || "");
+  process.stdin.setRawMode?.(true);
+  process.stdin.resume();
+  write(CSI2 + "?1000h" + CSI2 + "?1006h" + CSI2 + "?25l" + CSI2 + "2J");
+  process.on("exit", () => write(CSI2 + "?1000l" + CSI2 + "?1006l" + CSI2 + "?25h"));
+  if (kind === "menu") {
+    await runMenu(bootPath, repoCwd, argA, argB);
+    process.exit(0);
+  }
+  if (kind === "keybinds") {
+    await runKeybinds();
+    process.exit(0);
+  }
+  if (kind === "kill") {
+    await runKillConfirm(argA, argB);
+    process.exit(0);
+  }
+  if (kind === "tab") {
+    await runTabMenu(argA || "synkro-ui");
+    process.exit(0);
+  }
+  if (kind === "new-workspace") {
+    const repo = await pickRepo(repoCwd);
+    if (!repo) process.exit(0);
+    rememberRepo(repo);
+    const worktree = await pickWorktree(repo);
+    if (worktree) rememberSpace(await repoOf(worktree));
+    process.exit(0);
+  }
+  const harnesses = await detectHarnesses();
+  const sessions = [
+    { value: "terminal", label: TAB_GLYPHS.terminal + "  Terminal" },
+    ...harnesses.map((harness) => ({
+      value: harness,
+      label: (TAB_GLYPHS[harness] || "") + "  " + (HARNESS_LABELS[harness] || harness)
+    }))
+  ];
+  if (harnesses.includes("cursor")) {
+    sessions.push({ value: "cursor-synkro", label: TAB_GLYPHS.cursor + "  Cursor in Synkro UX" });
+  }
+  for (; ; ) {
+    const session = await pick({
+      menu: true,
+      title: "new tab",
+      hint: "choose what to run",
+      choices: sessions,
+      footer: "\u2191\u2193 select   \u21B5 next   esc close"
+    });
+    if (!session) process.exit(0);
+    const repo = await pickRepo(repoCwd);
+    if (!repo) continue;
+    rememberRepo(repo);
+    const worktree = await pickWorktree(repo);
+    if (!worktree) continue;
+    const root = await repoOf(worktree);
+    rememberRepo(root);
+    rememberSpace(root);
+    write(CSI2 + "2J" + CSI2 + "H " + S.dim + "starting " + session + "\u2026" + S.reset);
+    await createTab(bootPath, session, worktree);
+    process.exit(0);
+  }
+}
+var CSI2, KEY_ESC, KEY_CTRL_C2, KEY_BACKSPACE, S, HARNESS_LABELS, TYPE_PATH, NEW_WORKTREE, SAFE_BRANCH;
+var init_dialog = __esm({
+  "cli/ui/dialog.ts"() {
     "use strict";
+    init_backend();
+    init_model();
+    init_manifest();
+    init_repos();
+    init_tabs();
+    init_launch();
     init_tmux();
-    PUEUE_GROUP = "synkro-ui";
+    CSI2 = "\x1B[";
+    KEY_ESC = "\x1B";
+    KEY_CTRL_C2 = "";
+    KEY_BACKSPACE = "\x7F";
+    S = {
+      reset: CSI2 + "0m",
+      dim: CSI2 + "2m",
+      bold: CSI2 + "1m",
+      title: CSI2 + "1m" + CSI2 + "38;5;111m",
+      select: CSI2 + "48;5;238m",
+      accent: CSI2 + "38;5;111m",
+      muted: CSI2 + "38;5;245m",
+      error: CSI2 + "38;5;203m"
+    };
+    HARNESS_LABELS = {
+      claude: "Claude Code",
+      codex: "Codex",
+      cursor: "Cursor"
+    };
+    TYPE_PATH = "::type-path";
+    NEW_WORKTREE = "::new-worktree";
+    SAFE_BRANCH = /^[A-Za-z0-9._/-]{1,80}$/;
   }
 });
 
-// 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 + ")" };
+// cli/harness/events.ts
+function blockReason(raw) {
+  const text = String(raw || "").trim();
+  if (!text) return "blocked by policy";
+  const afterTag = text.match(/\[synkro:[^\]]*\]\s*(.+)/is);
+  if (afterTag) return afterTag[1].trim();
+  const afterHook = text.match(/blocked by a hook:\s*(.+)/is);
+  if (afterHook) return afterHook[1].trim();
+  return text;
+}
+var BLOCK_MARKER;
+var init_events = __esm({
+  "cli/harness/events.ts"() {
+    "use strict";
+    BLOCK_MARKER = /blocked by a hook|\[synkro:/i;
   }
-  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);
+});
+
+// cli/harness/cursor.ts
+function textOf(message) {
+  const content = message?.content;
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.filter((part) => part && (part.type === "text" || typeof part.text === "string")).map((part) => String(part.text || "")).join("").trim();
+}
+function toolPayload(toolCall) {
+  if (!toolCall) return { kind: "other", body: {} };
+  for (const [key, kind] of Object.entries(TOOL_KINDS)) {
+    if (toolCall[key]) return { kind, body: toolCall[key] };
+  }
+  const fallback = Object.keys(toolCall).find((key) => key.endsWith("ToolCall"));
+  return fallback ? { kind: "other", body: toolCall[fallback] } : { kind: "other", body: {} };
+}
+function targetOf(kind, body) {
+  const args2 = body?.args || {};
+  const candidate = args2.command ?? args2.path ?? args2.filePath ?? args2.file_path ?? args2.pattern ?? args2.query ?? args2.target ?? "";
+  const text = typeof candidate === "string" ? candidate : JSON.stringify(candidate ?? "");
+  return text || body?.description || kind;
+}
+function parseCursorLine(line) {
+  const trimmed = String(line || "").trim();
+  if (!trimmed) return [];
+  let frame;
+  try {
+    frame = JSON.parse(trimmed);
+  } catch {
+    return [];
   }
-  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 type = frame.type;
+  const subtype = frame.subtype;
+  if (type === "system" && subtype === "init") {
+    return [{
+      type: "session-start",
+      sessionId: String(frame.session_id || ""),
+      model: String(frame.model || ""),
+      cwd: String(frame.cwd || ""),
+      authSource: String(frame.apiKeySource || "")
+    }];
+  }
+  if (type === "user") {
+    const text = textOf(frame.message);
+    return text ? [{ type: "user-message", text }] : [];
+  }
+  if (type === "assistant") {
+    const text = textOf(frame.message);
+    return text ? [{ type: "assistant-message", text }] : [];
+  }
+  if (type === "thinking" && subtype === "delta" && frame.text) {
+    return [{ type: "thinking", text: String(frame.text) }];
+  }
+  if (type === "tool_call") {
+    const { kind, body } = toolPayload(frame.tool_call);
+    const id = String(frame.call_id || frame.tool_call?.toolCallId || "");
+    const target = targetOf(kind, body);
+    const description = String(body?.description || frame.tool_call?.description || "");
+    if (subtype === "started") {
+      return [{ type: "tool-start", id, kind, target, description }];
+    }
+    if (subtype === "completed") {
+      const result = body?.result || {};
+      const success = result.success;
+      const rejected = result.rejected;
+      const rawReason = String(rejected?.reason || "");
+      const blocked = Boolean(rejected) && BLOCK_MARKER.test(rawReason);
+      return [{
+        type: "tool-end",
+        id,
+        kind,
+        target: target || String(rejected?.command || ""),
+        ok: Boolean(success) && Number(success?.exitCode ?? 0) === 0,
+        blocked,
+        reason: rejected ? blocked ? blockReason(rawReason) : rawReason || "rejected" : "",
+        exitCode: success ? Number(success.exitCode ?? 0) : null,
+        output: String(success?.stdout || success?.stderr || "")
+      }];
     }
+    return [];
   }
-  const pueueId = await registerAgent(runner, session);
-  if (pueueId) await run(runner, buildSetOption(session, "@synkro_pueue", pueueId));
-  return { ok: true, session };
+  if (type === "result") {
+    return [{
+      type: "turn-end",
+      ok: !frame.is_error,
+      text: String(frame.result || "")
+    }];
+  }
+  return [];
 }
-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);
+function feed(buffer, chunk) {
+  const combined = buffer + chunk;
+  const parts = combined.split("\n");
+  const rest = parts.pop() ?? "";
+  return { lines: parts, rest };
 }
-var CONTAINER_NAME2, CONTAINER_WORK, AUTH_SEED;
-var init_backend = __esm({
-  "cli/ui/backend.ts"() {
+function cursorArgs(prompt) {
+  return [
+    "-p",
+    prompt,
+    "--output-format",
+    "stream-json",
+    // --force auto-runs tools but does NOT bypass hooks (verified live), so
+    // Synkro's guards still gate every call; --trust loads workspace hooks.
+    "--force",
+    "--trust"
+  ];
+}
+var TOOL_KINDS;
+var init_cursor = __esm({
+  "cli/harness/cursor.ts"() {
     "use strict";
-    init_tmux();
-    init_pueue2();
-    CONTAINER_NAME2 = "synkro-server";
-    CONTAINER_WORK = "/home/synkro/work";
-    AUTH_SEED = CONTAINER_WORK + "/claude-1/.claude.json";
+    init_events();
+    TOOL_KINDS = {
+      shellToolCall: "shell",
+      readToolCall: "read",
+      editToolCall: "edit",
+      writeToolCall: "write",
+      deleteToolCall: "delete",
+      grepToolCall: "search",
+      globToolCall: "search",
+      lsToolCall: "list",
+      todoToolCall: "todo",
+      updateTodosToolCall: "todo"
+    };
   }
 });
 
-// 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);
+// cli/harness/render.ts
+function clip3(text, max) {
+  const value = String(text || "").replace(/\s+/g, " ").trim();
+  return value.length <= max ? value : value.slice(0, max - 1) + "\u2026";
+}
+function renderEvent(event, width = 100) {
+  const body = Math.max(30, width - 4);
+  switch (event.type) {
+    case "session-start":
+      return [
+        "",
+        S2.dim + "  " + event.model + "  \xB7  " + clip3(event.cwd, body - 30) + (event.authSource === "login" ? "  \xB7  subscription" : "") + S2.reset,
+        ""
+      ];
+    case "user-message":
+      return ["", S2.user + "  \u276F " + S2.reset + S2.bold + clip3(event.text, body) + S2.reset, ""];
+    case "thinking":
+      return [S2.think + "  \xB7 thinking\u2026" + S2.reset];
+    case "assistant-message":
+      return ["", ...wrap(event.text, body).map((line) => S2.agent + "  " + line + S2.reset), ""];
+    case "tool-start": {
+      const glyph = GLYPH[event.kind] || GLYPH.other;
+      return [S2.tool + "  " + glyph + " " + S2.reset + S2.dim + clip3(event.target, body - 6) + S2.reset];
+    }
+    case "tool-end": {
+      if (event.blocked) {
+        return [
+          S2.blocked + "  \u26D4 blocked" + S2.reset + S2.dim + "  " + clip3(event.target, body - 14) + S2.reset,
+          ...wrap(event.reason, body - 6).map((line) => "     " + S2.rule + line + S2.reset)
+        ];
+      }
+      const mark = event.ok ? S2.ok + "  \u2713" : S2.blocked + "  \u2717";
+      const code = event.exitCode === null || event.exitCode === 0 ? "" : " (exit " + event.exitCode + ")";
+      const out = event.output.trim() ? S2.dim + "  " + clip3(event.output, body - 20) + S2.reset : "";
+      return [mark + S2.reset + code + out];
+    }
+    case "turn-end":
+      return ["", S2.dim + "  " + (event.ok ? "done" : "ended with an error") + S2.reset, ""];
+    case "notice":
+      return [S2.dim + "  " + clip3(event.text, body) + S2.reset];
+    default:
+      return [];
   }
-  async function spawnContainerAgent() {
-    if (info.backend !== "container") {
-      state.message = "container runtime unavailable";
-      return;
+}
+function wrap(text, width) {
+  const words = String(text || "").replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+  if (words.length === 0) return [];
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if (!line) line = word;
+    else if ((line + " " + word).length <= width) line += " " + word;
+    else {
+      lines.push(line);
+      line = word;
     }
-    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]);
+  if (line) lines.push(line);
+  return lines;
+}
+var ESC2, S2, GLYPH;
+var init_render2 = __esm({
+  "cli/harness/render.ts"() {
+    "use strict";
+    ESC2 = "\x1B[";
+    S2 = {
+      reset: ESC2 + "0m",
+      dim: ESC2 + "2m",
+      bold: ESC2 + "1m",
+      user: ESC2 + "38;5;111m",
+      agent: ESC2 + "38;5;252m",
+      think: ESC2 + "38;5;244m",
+      tool: ESC2 + "38;5;180m",
+      ok: ESC2 + "38;5;114m",
+      blocked: ESC2 + "38;5;203m",
+      rule: ESC2 + "38;5;211m"
+    };
+    GLYPH = {
+      shell: "\u276F",
+      read: "\u25C4",
+      edit: "\u270E",
+      write: "\u270E",
+      delete: "\u2716",
+      search: "\u2315",
+      list: "\u2630",
+      todo: "\u2611",
+      other: "\u2022"
+    };
   }
-  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;
+});
+
+// cli/harness/run.ts
+import { spawn as spawn9 } from "child_process";
+async function runCursorTurn(opts) {
+  const write2 = opts.write || ((text) => process.stdout.write(text));
+  const width = opts.width || Number(process.stdout.columns || 100);
+  const events = [];
+  let blocked = 0;
+  let lastWasThinking = false;
+  return new Promise((resolve7) => {
+    const child = spawn9("cursor-agent", cursorArgs(opts.prompt), {
+      cwd: opts.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let buffer = "";
+    child.stdout.on("data", (chunk) => {
+      const { lines, rest } = feed(buffer, chunk.toString("utf8"));
+      buffer = rest;
+      for (const line of lines) {
+        for (const event of parseCursorLine(line)) {
+          events.push(event);
+          if (event.type === "tool-end" && event.blocked) blocked += 1;
+          opts.onEvent?.(event);
+          if (event.type === "thinking") {
+            if (lastWasThinking) continue;
+            lastWasThinking = true;
+          } else {
+            lastWasThinking = false;
+          }
+          const rendered = renderEvent(event, width);
+          if (rendered.length) write2(rendered.join("\n") + "\n");
         }
-      } 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();
-    })();
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString("utf8").trim();
+      if (/error|fatal/i.test(text) && !/RetriableError/i.test(text)) {
+        write2(renderEvent({ type: "notice", text }, width).join("\n") + "\n");
+      }
+    });
+    child.on("close", (code) => {
+      resolve7({ events, blocked, exitCode: code ?? 0 });
+    });
+    child.on("error", (error) => {
+      write2(renderEvent({ type: "notice", text: "failed to start cursor-agent: " + String(error) }, width).join("\n") + "\n");
+      resolve7({ events, blocked, exitCode: 1 });
+    });
   });
-  await refresh();
-  draw();
-  setInterval(() => {
-    void refresh().then(draw);
-  }, POLL_MS);
 }
-var POLL_MS, CONDUCTOR_URL;
-var init_sidebar = __esm({
-  "cli/ui/sidebar.ts"() {
+var init_run = __esm({
+  "cli/harness/run.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");
+    init_cursor();
+    init_render2();
+  }
+});
+
+// cli/harness/session.ts
+import { createInterface as createInterface5 } from "readline";
+async function runOnce(harness, cwd, prompt) {
+  if (harness !== "cursor") {
+    process.stdout.write(S2.dim + "  " + harness + " sessions are not embedded yet\n" + S2.reset);
+    return 1;
+  }
+  const result = await runCursorTurn({ prompt, cwd });
+  if (result.blocked > 0) {
+    process.stdout.write(
+      S2.blocked + "  " + result.blocked + " action" + (result.blocked === 1 ? "" : "s") + " blocked by policy" + S2.reset + "\n"
+    );
+  }
+  return result.exitCode;
+}
+async function runGovernedSession(harness, cwd, prompt) {
+  if (prompt) return runOnce(harness, cwd, prompt);
+  process.stdout.write(BANNER.join("\n") + "\n");
+  const rl = createInterface5({ input: process.stdin, output: process.stdout });
+  const ask3 = () => new Promise((resolve7) => rl.question(S2.user + "  \u276F " + S2.reset, resolve7));
+  for (; ; ) {
+    const line = (await ask3()).trim();
+    if (!line) continue;
+    if (line === "exit" || line === "quit") break;
+    await runOnce(harness, cwd, line);
+  }
+  rl.close();
+  return 0;
+}
+var BANNER;
+var init_session = __esm({
+  "cli/harness/session.ts"() {
+    "use strict";
+    init_run();
+    init_render2();
+    BANNER = [
+      "",
+      S2.bold + "  synkro" + S2.reset + S2.dim + "  governed session" + S2.reset,
+      S2.dim + "  every tool call passes Synkro policy before it runs" + S2.reset,
+      S2.dim + "  ctrl-c to leave" + S2.reset,
+      ""
+    ];
   }
 });
 
@@ -15190,22 +17028,68 @@ 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();
-  }
-}
+import { execSync as execSync8 } from "child_process";
 function tmuxPresent() {
   try {
-    execSync7("tmux -V", { stdio: ["pipe", "pipe", "pipe"] });
+    execSync8("tmux -V", { stdio: ["pipe", "pipe", "pipe"] });
     return true;
   } catch {
     return false;
   }
 }
+async function takeover(kind, cwd) {
+  const harness = ["claude", "codex", "cursor"].includes(kind) ? kind : "claude";
+  const info = await detectContainerBackend();
+  const reachable = info.backend === "container" ? (await run(info.runner, ["test", "-d", cwd])).ok : false;
+  const backend = reachable ? "container" : "host";
+  const spaceName = cwd.split("/").filter(Boolean).pop() || "space";
+  const spawned = await spawnAgent(info, {
+    name: spaceName + "-" + harness + "-" + String(process.pid % 1e4),
+    harness,
+    spaceName,
+    cwd,
+    backend
+  });
+  if (!spawned.ok) {
+    console.error("synkro: spawn failed: " + (spawned.error || "unknown"));
+    return 1;
+  }
+  if (process.env.TMUX_PANE) {
+    await run(HOST3, ["tmux", "rename-window", "-t", process.env.TMUX_PANE, tabTitle(harness, spaceName)]);
+  }
+  const runner = backend === "container" ? info.runner : HOST3;
+  return runInherit(["env", "TMUX=", ...runnerInteractiveArgs(runner, ["tmux", "attach-session", "-t", spawned.session])]);
+}
+async function restoreSession(session) {
+  const record = loadRecords().find((row2) => row2.session === session);
+  if (!record) return;
+  const info = await detectContainerBackend();
+  await spawnAgent(info, {
+    name: record.name,
+    harness: record.harness,
+    spaceName: record.spaceName,
+    cwd: record.space,
+    backend: record.backend,
+    resume: true
+  });
+}
+async function printStatus() {
+  const info = await detectContainerBackend();
+  const [hostAgents, containerAgents] = await Promise.all([
+    discoverAgents({ kind: "host" }, "host", /* @__PURE__ */ new Map()),
+    info.backend === "container" ? discoverAgents(info.runner, "container", /* @__PURE__ */ new Map()) : Promise.resolve({ agents: [], hashes: /* @__PURE__ */ new Map() })
+  ]);
+  const live = [...hostAgents.agents, ...containerAgents.agents];
+  const rows = [...live, ...offlineAgents(live, loadRecords())];
+  if (rows.length === 0) {
+    console.log("no sessions. `synkro ui` to start one.");
+    return;
+  }
+  for (const agent of rows) {
+    console.log([agent.status.padEnd(8), agent.harness.padEnd(7), agent.name, agent.space || ""].join(" "));
+  }
+  console.log("\n`synkro ui` to attach" + (rows.some((agent) => agent.status === "offline") ? "; offline sessions restore with r" : ""));
+}
 async function uiCommand(args2) {
   const bootPath = String(process.argv[1] || "");
   if (args2.includes("--sidebar")) {
@@ -15214,8 +17098,53 @@ async function uiCommand(args2) {
     });
     return;
   }
-  if (args2.includes("--new-tab")) {
-    await buildTab(bootPath, repoRoot(), "new");
+  const dialogAt = args2.indexOf("--dialog");
+  if (dialogAt !== -1) {
+    await runDialog(
+      args2[dialogAt + 1] || "new-tab",
+      args2[dialogAt + 2] || repoRoot(),
+      args2[dialogAt + 3] || "",
+      args2[dialogAt + 4] || ""
+    );
+    return;
+  }
+  const tabAt = args2.indexOf("--tab");
+  if (tabAt !== -1) {
+    await createTab(bootPath, args2[tabAt + 1] || "terminal", args2[tabAt + 2] || repoRoot());
+    return;
+  }
+  const openAt = args2.indexOf("--open-agent");
+  if (openAt !== -1) {
+    await openAgentTab(bootPath, args2[openAt + 1] || "");
+    return;
+  }
+  const runAt = args2.indexOf("--run");
+  if (runAt !== -1) {
+    const harness = args2[runAt + 1] || "cursor";
+    const cwd = args2[runAt + 2] || repoRoot();
+    const prompt = args2.slice(runAt + 3).join(" ").trim();
+    process.exitCode = await runGovernedSession(harness, cwd, prompt);
+    return;
+  }
+  const takeoverAt = args2.indexOf("--takeover");
+  if (takeoverAt !== -1) {
+    process.exitCode = await takeover(args2[takeoverAt + 1] || "claude", args2[takeoverAt + 2] || process.cwd());
+    return;
+  }
+  const restoreAt = args2.indexOf("--restore");
+  if (restoreAt !== -1) {
+    await restoreSession(args2[restoreAt + 1] || "");
+    return;
+  }
+  if (args2.includes("--status")) {
+    await printStatus();
+    return;
+  }
+  const killAt = args2.indexOf("--kill-agent");
+  if (killAt !== -1) {
+    const backend = args2[killAt + 1] === "container" ? "container" : "host";
+    const session = args2[killAt + 2] || "";
+    if (session.startsWith("synkro-agent-")) await killAgent(backend, session, "");
     return;
   }
   if (!tmuxPresent()) {
@@ -15223,14 +17152,26 @@ async function uiCommand(args2) {
     process.exitCode = 1;
     return;
   }
-  const code = await launchUi(bootPath, repoRoot());
+  const repo = repoRoot();
+  if (!await uiSessionExists()) await restoreTabs(bootPath, repo);
+  const code = await launchUi(bootPath, repo);
   process.exitCode = code;
 }
+var HOST3;
 var init_ui = __esm({
   "cli/commands/ui.ts"() {
     "use strict";
     init_launch();
     init_sidebar();
+    init_dialog();
+    init_tabs();
+    init_session();
+    init_launch();
+    init_backend();
+    init_model();
+    init_manifest();
+    init_tmux();
+    HOST3 = { kind: "host" };
   }
 });
 
@@ -15270,12 +17211,12 @@ __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";
+import { readFileSync as readFileSync33 } from "fs";
+import { homedir as homedir38 } from "os";
+import { join as join37 } from "path";
 function mcpJwt() {
   try {
-    return readFileSync30(join32(SYNKRO_DIR14, ".mcp-jwt"), "utf-8").trim();
+    return readFileSync33(join37(SYNKRO_DIR14, ".mcp-jwt"), "utf-8").trim();
   } catch {
     return "";
   }
@@ -15314,7 +17255,7 @@ var SYNKRO_DIR14, PORT2, BASE;
 var init_linear = __esm({
   "cli/commands/linear.ts"() {
     "use strict";
-    SYNKRO_DIR14 = join32(homedir32(), ".synkro");
+    SYNKRO_DIR14 = join37(homedir38(), ".synkro");
     PORT2 = process.env.SYNKRO_MCP_PORT || "18931";
     BASE = `http://127.0.0.1:${PORT2}`;
   }
@@ -15322,7 +17263,7 @@ var init_linear = __esm({
 
 // cli/scanning/cveReachability.ts
 import { parse } from "@babel/parser";
-import { readFileSync as readFileSync31 } from "fs";
+import { readFileSync as readFileSync34 } from "fs";
 function walk(node, visit) {
   if (!node || typeof node.type !== "string") return;
   visit(node);
@@ -15464,12 +17405,12 @@ var init_cveReachability = __esm({
 
 // cli/reachability/reachabilityScan.ts
 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 { readFileSync as readFileSync35, writeFileSync as writeFileSync27, existsSync as existsSync38, readdirSync as readdirSync10 } from "fs";
+import { join as join38 } from "path";
+import { homedir as homedir39 } from "os";
 import { createRequire } from "module";
 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 SKIP2 = /* @__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 = [repoRoot3];
@@ -15477,21 +17418,21 @@ function walkSourceFiles(repoRoot3, maxFiles = 4e3, maxBytes = 5e5) {
     const dir = stack.pop();
     let ents;
     try {
-      ents = readdirSync9(dir, { withFileTypes: true });
+      ents = readdirSync10(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of ents) {
       if (files.length >= maxFiles) break;
-      const full = join33(dir, e.name);
+      const full = join38(dir, e.name);
       if (e.isDirectory()) {
-        if (!SKIP.has(e.name) && !e.name.startsWith(".")) stack.push(full);
+        if (!SKIP2.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(repoRoot3 + "/") ? full.slice(repoRoot3.length + 1) : full;
       try {
-        const content = readFileSync32(full, "utf8");
+        const content = readFileSync35(full, "utf8");
         if (content.length <= maxBytes) files.push({ path: rel, content });
       } catch {
       }
@@ -15510,12 +17451,12 @@ function cleanVersion(spec) {
 function gatherManifestVersions(repoRoot3) {
   const out = {};
   const dirs = [repoRoot3];
-  const pkgsDir = join33(repoRoot3, "packages");
-  if (existsSync34(pkgsDir)) {
+  const pkgsDir = join38(repoRoot3, "packages");
+  if (existsSync38(pkgsDir)) {
     try {
-      for (const d of readdirSync9(pkgsDir)) {
-        const pd = join33(pkgsDir, d);
-        if (existsSync34(join33(pd, "package.json"))) dirs.push(pd);
+      for (const d of readdirSync10(pkgsDir)) {
+        const pd = join38(pkgsDir, d);
+        if (existsSync38(join38(pd, "package.json"))) dirs.push(pd);
       }
     } catch {
     }
@@ -15524,7 +17465,7 @@ function gatherManifestVersions(repoRoot3) {
   for (const dir of dirs) {
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync32(join33(dir, "package.json"), "utf8"));
+      pkg = JSON.parse(readFileSync35(join38(dir, "package.json"), "utf8"));
     } catch {
       continue;
     }
@@ -15544,28 +17485,28 @@ 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 pkg = JSON.parse(readFileSync35(pkgJson, "utf8"));
     const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin && (pkg.bin.jelly || pkg.bin[Object.keys(pkg.bin)[0]]);
     if (bin) {
-      const p = join33(dir, bin);
-      if (existsSync34(p)) return p;
+      const p = join38(dir, bin);
+      if (existsSync38(p)) return p;
     }
   } catch {
   }
   for (const base of [repoRoot3, process.cwd()]) {
-    const b = join33(base, "node_modules", ".bin", "jelly");
-    if (existsSync34(b)) return b;
+    const b = join38(base, "node_modules", ".bin", "jelly");
+    if (existsSync38(b)) return b;
   }
   return null;
 }
 function findEntries(repoRoot3) {
   const dirs = [repoRoot3];
-  const pkgsDir = join33(repoRoot3, "packages");
-  if (existsSync34(pkgsDir)) {
+  const pkgsDir = join38(repoRoot3, "packages");
+  if (existsSync38(pkgsDir)) {
     try {
-      for (const d of readdirSync9(pkgsDir)) {
-        const pd = join33(pkgsDir, d);
-        if (existsSync34(join33(pd, "package.json"))) dirs.push(pd);
+      for (const d of readdirSync10(pkgsDir)) {
+        const pd = join38(pkgsDir, d);
+        if (existsSync38(join38(pd, "package.json"))) dirs.push(pd);
       }
     } catch {
     }
@@ -15573,12 +17514,12 @@ function findEntries(repoRoot3) {
   const entries = [];
   for (const dir of dirs) {
     try {
-      const pkg = JSON.parse(readFileSync32(join33(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync35(join38(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 = join33(dir, c);
-        if (existsSync34(f)) {
+        const f = join38(dir, c);
+        if (existsSync38(f)) {
           entries.push(f);
           break;
         }
@@ -15611,9 +17552,9 @@ function parseApiUsage(log) {
 }
 function runReachabilityScan(repoRoot3, opts = {}) {
   const commit = currentCommit(repoRoot3);
-  if (!opts.force && commit && existsSync34(REACHABILITY_PATH)) {
+  if (!opts.force && commit && existsSync38(REACHABILITY_PATH)) {
     try {
-      const prev = JSON.parse(readFileSync32(REACHABILITY_PATH, "utf8"));
+      const prev = JSON.parse(readFileSync35(REACHABILITY_PATH, "utf8"));
       if (prev.commit === commit) return { ok: true, cached: true, packages: Object.keys(prev.packages || {}).length };
     } catch {
     }
@@ -15702,7 +17643,7 @@ function runReachabilityScan(repoRoot3, opts = {}) {
   if (Object.keys(packages).length === 0) return { ok: false, reason: "no package usage found (no jelly output, no AST imports)" };
   const file = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), commit, tool, packages, versions: gatherManifestVersions(repoRoot3) };
   try {
-    writeFileSync23(REACHABILITY_PATH, JSON.stringify(file, null, 2));
+    writeFileSync27(REACHABILITY_PATH, JSON.stringify(file, null, 2));
   } catch (e) {
     return { ok: false, reason: "write failed: " + String(e.message || e) };
   }
@@ -15714,7 +17655,7 @@ var init_reachabilityScan = __esm({
     "use strict";
     init_cveReachability();
     require2 = createRequire(import.meta.url);
-    REACHABILITY_PATH = join33(homedir33(), ".synkro", "reachability.json");
+    REACHABILITY_PATH = join38(homedir39(), ".synkro", "reachability.json");
   }
 });
 
@@ -15723,15 +17664,15 @@ var reachabilityScan_exports = {};
 __export(reachabilityScan_exports, {
   reachabilityScanCommand: () => reachabilityScanCommand
 });
-import { readFileSync as readFileSync33, existsSync as existsSync35 } from "fs";
-import { join as join34 } from "path";
-import { homedir as homedir34 } from "os";
+import { readFileSync as readFileSync36, existsSync as existsSync39 } from "fs";
+import { join as join39 } from "path";
+import { homedir as homedir40 } from "os";
 import { execFileSync as execFileSync6 } from "child_process";
 function readConfigEnv4() {
-  const p = join34(SYNKRO_DIR15, "config.env");
-  if (!existsSync35(p)) return {};
+  const p = join39(SYNKRO_DIR15, "config.env");
+  if (!existsSync39(p)) return {};
   const out = {};
-  for (const line of readFileSync33(p, "utf-8").split("\n")) {
+  for (const line of readFileSync36(p, "utf-8").split("\n")) {
     const t = line.trim();
     if (!t || t.startsWith("#")) continue;
     const eq = t.indexOf("=");
@@ -15763,11 +17704,11 @@ async function pushToCloud(cfg, repo) {
   while (gwBase.endsWith("/")) gwBase = gwBase.slice(0, -1);
   let jwt2 = "";
   try {
-    jwt2 = readFileSync33(join34(SYNKRO_DIR15, ".mcp-jwt"), "utf-8").trim();
+    jwt2 = readFileSync36(join39(SYNKRO_DIR15, ".mcp-jwt"), "utf-8").trim();
   } catch {
   }
-  if (!jwt2 || !existsSync35(REACHABILITY_PATH)) return;
-  const body = readFileSync33(REACHABILITY_PATH, "utf-8");
+  if (!jwt2 || !existsSync39(REACHABILITY_PATH)) return;
+  const body = readFileSync36(REACHABILITY_PATH, "utf-8");
   try {
     const resp = await fetch(gwBase + "/api/v1/reachability?repo=" + encodeURIComponent(repo), {
       method: "POST",
@@ -15799,7 +17740,7 @@ var init_reachabilityScan2 = __esm({
   "cli/commands/reachabilityScan.ts"() {
     "use strict";
     init_reachabilityScan();
-    SYNKRO_DIR15 = join34(homedir34(), ".synkro");
+    SYNKRO_DIR15 = join39(homedir40(), ".synkro");
   }
 });
 
@@ -15929,13 +17870,13 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync24, existsSync as existsSync36 } from "fs";
-import { join as join35 } from "path";
-import { homedir as homedir35 } from "os";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync28, existsSync as existsSync40 } from "fs";
+import { join as join40 } from "path";
+import { homedir as homedir41 } from "os";
 function readConfigEnv5() {
-  if (!existsSync36(CONFIG_PATH9)) return {};
+  if (!existsSync40(CONFIG_PATH9)) return {};
   const out = {};
-  for (const line of readFileSync34(CONFIG_PATH9, "utf-8").split("\n")) {
+  for (const line of readFileSync37(CONFIG_PATH9, "utf-8").split("\n")) {
     const t = line.trim();
     if (!t || t.startsWith("#")) continue;
     const eq = t.indexOf("=");
@@ -15944,11 +17885,11 @@ function readConfigEnv5() {
   return out;
 }
 function updateConfigValue(key, value) {
-  if (!existsSync36(CONFIG_PATH9)) {
+  if (!existsSync40(CONFIG_PATH9)) {
     console.error("No config found. Run `synkro install` first.");
     process.exit(1);
   }
-  const lines = readFileSync34(CONFIG_PATH9, "utf-8").split("\n");
+  const lines = readFileSync37(CONFIG_PATH9, "utf-8").split("\n");
   const pattern = new RegExp(`^${key}=`);
   let found = false;
   const updated = lines.map((line) => {
@@ -15959,7 +17900,7 @@ function updateConfigValue(key, value) {
     return line;
   });
   if (!found) updated.splice(updated.length - 1, 0, `${key}='${value}'`);
-  writeFileSync24(CONFIG_PATH9, updated.join("\n"), "utf-8");
+  writeFileSync28(CONFIG_PATH9, updated.join("\n"), "utf-8");
 }
 function resolveInferenceMode(cfg) {
   if ((cfg.SYNKRO_GRADING_MODE || "local") === "byok") return "byok";
@@ -16117,8 +18058,8 @@ var init_config = __esm({
     "use strict";
     init_stub();
     init_optout();
-    SYNKRO_DIR16 = join35(homedir35(), ".synkro");
-    CONFIG_PATH9 = join35(SYNKRO_DIR16, "config.env");
+    SYNKRO_DIR16 = join40(homedir41(), ".synkro");
+    CONFIG_PATH9 = join40(SYNKRO_DIR16, "config.env");
   }
 });
 
@@ -16127,7 +18068,7 @@ var telemetry_exports2 = {};
 __export(telemetry_exports2, {
   telemetryCommand: () => telemetryCommand
 });
-import { createInterface as createInterface5 } from "readline";
+import { createInterface as createInterface6 } from "readline";
 function parseFlag(args2, name) {
   const prefix = `--${name}=`;
   for (const a of args2) if (a.startsWith(prefix)) return a.slice(prefix.length);
@@ -16209,7 +18150,7 @@ async function runExport(args2) {
 function confirmYesNo(question) {
   if (!process.stdin.isTTY) return Promise.resolve(false);
   return new Promise((resolve7) => {
-    const rl = createInterface5({ input: process.stdin, output: process.stdout });
+    const rl = createInterface6({ input: process.stdin, output: process.stdout });
     rl.question(`${question} (y/N): `, (answer) => {
       rl.close();
       const t = answer.trim().toLowerCase();
@@ -16308,11 +18249,11 @@ 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";
+import { existsSync as existsSync41, mkdirSync as mkdirSync24, readFileSync as readFileSync38, renameSync as renameSync9, writeFileSync as writeFileSync29 } from "fs";
+import { homedir as homedir42 } from "os";
+import { dirname as dirname12, join as join41 } from "path";
 function operationalIdentityPath() {
-  return process.env.SYNKRO_OPERATIONAL_IDENTITY_PATH || join36(homedir36(), ".synkro", "installation.json");
+  return process.env.SYNKRO_OPERATIONAL_IDENTITY_PATH || join41(homedir42(), ".synkro", "installation.json");
 }
 function validIdentity(value) {
   if (!value || typeof value !== "object") return false;
@@ -16320,17 +18261,17 @@ function validIdentity(value) {
   return typeof row2.installation_id === "string" && UUID_RE.test(row2.installation_id) && typeof row2.created_at === "string" && Number.isFinite(Date.parse(row2.created_at));
 }
 function writeIdentity(path, identity) {
-  mkdirSync20(dirname9(path), { recursive: true, mode: 448 });
+  mkdirSync24(dirname12(path), { recursive: true, mode: 448 });
   const temp = `${path}.${process.pid}.${randomUUID5()}.tmp`;
-  writeFileSync25(temp, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  writeFileSync29(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)) {
+  if (existsSync41(path)) {
     try {
-      const parsed = JSON.parse(readFileSync35(path, "utf8"));
+      const parsed = JSON.parse(readFileSync38(path, "utf8"));
       if (validIdentity(parsed)) {
         cached4.set(path, parsed);
         return parsed;
@@ -16355,13 +18296,13 @@ var init_identity2 = __esm({
 // cli/inventory/collector.ts
 import { createHash as createHash5 } from "crypto";
 import {
-  existsSync as existsSync38,
-  readFileSync as readFileSync36,
-  readdirSync as readdirSync10,
+  existsSync as existsSync42,
+  readFileSync as readFileSync39,
+  readdirSync as readdirSync11,
   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 { arch, homedir as homedir43, hostname as hostname2, platform as platform6, release as release2 } from "os";
+import { basename as basename3, join as join42, relative, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 function sha256(value) {
   return createHash5("sha256").update(value).digest("hex");
@@ -16371,15 +18312,15 @@ function pseudonymousHostnameHash(installationId, host) {
 }
 function cliVersion() {
   try {
-    return "1.10.3";
+    return "1.10.4";
   } catch {
     return "0.0.0";
   }
 }
 function readJson(path) {
   try {
-    if (!existsSync38(path)) return null;
-    const parsed = JSON.parse(readFileSync36(path, "utf8"));
+    if (!existsSync42(path)) return null;
+    const parsed = JSON.parse(readFileSync39(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -16387,8 +18328,8 @@ function readJson(path) {
 }
 function readText(path) {
   try {
-    if (!existsSync38(path)) return "";
-    return readFileSync36(path, "utf8");
+    if (!existsSync42(path)) return "";
+    return readFileSync39(path, "utf8");
   } catch {
     return "";
   }
@@ -16474,16 +18415,16 @@ function mcpArtifactsFromJson(harness, config, configScope = "user") {
 }
 function claudeDesktopConfigCandidates(home, targetPlatform) {
   if (targetPlatform === "darwin") {
-    return [join37(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")];
+    return [join42(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")
+      join42(home, ".config", "Claude", "claude_desktop_config.json"),
+      join42(home, ".config", "claude", "claude_desktop_config.json")
     ];
   }
   if (targetPlatform === "win32" && process.env.APPDATA) {
-    return [join37(process.env.APPDATA, "Claude", "claude_desktop_config.json")];
+    return [join42(process.env.APPDATA, "Claude", "claude_desktop_config.json")];
   }
   return [];
 }
@@ -16491,7 +18432,7 @@ function claudeManagedMcpConfigCandidates(targetPlatform) {
   if (targetPlatform === "darwin") return ["/Library/Application Support/ClaudeCode/managed-mcp.json"];
   if (targetPlatform === "linux") return ["/etc/claude-code/managed-mcp.json"];
   if (targetPlatform === "win32" && process.env.ProgramFiles) {
-    return [join37(process.env.ProgramFiles, "ClaudeCode", "managed-mcp.json")];
+    return [join42(process.env.ProgramFiles, "ClaudeCode", "managed-mcp.json")];
   }
   return [];
 }
@@ -16500,7 +18441,7 @@ function discoveredProjectRoots(claudeState, currentDirectory, explicit = [], cu
   const add = (value) => {
     if (typeof value !== "string" || !value.trim()) return;
     const path = resolve5(value);
-    if (existsSync38(path)) roots.add(path);
+    if (existsSync42(path)) roots.add(path);
   };
   add(currentDirectory);
   for (const path of explicit) add(path);
@@ -16511,31 +18452,31 @@ function discoveredProjectRoots(claudeState, currentDirectory, explicit = [], cu
   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 === "darwin") return [join42(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage")];
+  if (targetPlatform === "linux") return [join42(home, ".config", "Cursor", "User", "workspaceStorage")];
   if (targetPlatform === "win32" && process.env.APPDATA) {
-    return [join37(process.env.APPDATA, "Cursor", "User", "workspaceStorage")];
+    return [join42(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;
+    if (!existsSync42(storage)) continue;
     let entries = [];
     try {
-      entries = readdirSync10(storage, { withFileTypes: true });
+      entries = readdirSync11(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 state = readJson(join42(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));
+        if (existsSync42(path)) roots.add(resolve5(path));
       } catch {
       }
     }
@@ -16629,18 +18570,18 @@ function parseFrontmatter(content) {
   return { name: value("name"), version: value("version") };
 }
 function skillArtifacts(harness, root) {
-  if (!existsSync38(root)) return [];
+  if (!existsSync42(root)) return [];
   const manifests = [];
   const visit = (dir) => {
     let entries;
     try {
-      entries = readdirSync10(dir, { withFileTypes: true });
+      entries = readdirSync11(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink?.()) continue;
-      const path = join37(dir, entry.name);
+      const path = join42(dir, entry.name);
       if (entry.isFile() && entry.name === "SKILL.md") manifests.push(path);
       else if (entry.isDirectory()) visit(path);
     }
@@ -16650,7 +18591,7 @@ function skillArtifacts(harness, root) {
     const content = readText(path);
     const frontmatter = parseFrontmatter(content);
     const rel = relative(root, path).replaceAll("\\", "/");
-    const name = frontmatter.name || basename3(join37(path, "..")) || "skill";
+    const name = frontmatter.name || basename3(join42(path, "..")) || "skill";
     return {
       harness,
       type: "skill",
@@ -16665,16 +18606,16 @@ function skillArtifacts(harness, root) {
   });
 }
 function cursorExtensionArtifacts(root) {
-  if (!existsSync38(root)) return [];
+  if (!existsSync42(root)) return [];
   let dirs = [];
   try {
-    dirs = readdirSync10(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink());
+    dirs = readdirSync11(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"));
+    const pkg = readJson(join42(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;
@@ -16694,21 +18635,21 @@ function cursorExtensionArtifacts(root) {
   return artifacts;
 }
 function deploymentMode2(home) {
-  const raw = readText(join37(home, ".synkro", "config.env"));
+  const raw = readText(join42(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 meta = readJson(join42(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");
+  const queue = join42(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);
+    health.telemetry_backlog = size <= 5 * 1024 * 1024 ? readFileSync39(queue, "utf8").split("\n").filter(Boolean).length : Math.ceil(size / 1024);
   } catch {
   }
   return health;
@@ -16749,7 +18690,7 @@ function harnessSnapshot(agent) {
   }
   const config = readJson(agent.settingsPath);
   const coverage = inspectCodexHooks(agent.settingsPath);
-  const toml = readText(join37(agent.configDir, "config.toml"));
+  const toml = readText(join42(agent.configDir, "config.toml"));
   const permission = toml.match(/^\s*approval_policy\s*=\s*["']([^"']+)/m)?.[1];
   return {
     row: {
@@ -16766,11 +18707,11 @@ function harnessSnapshot(agent) {
   };
 }
 function collectOperationalInventory(options = {}) {
-  const home = options.homeDir ?? homedir37();
+  const home = options.homeDir ?? homedir43();
   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 targetPlatform = options.platformName ?? platform6();
+  const codexHome = options.homeDir ? join42(home, ".codex") : process.env.CODEX_HOME || join42(home, ".codex");
   const harnesses = [];
   const artifacts = [];
   for (const agent of detected) {
@@ -16778,7 +18719,7 @@ function collectOperationalInventory(options = {}) {
     harnesses.push(row2);
     artifacts.push(...hookArtifacts(row2.harness, config));
   }
-  const claudeJson = readJson(join37(home, ".claude.json"));
+  const claudeJson = readJson(join42(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)) {
@@ -16786,8 +18727,8 @@ function collectOperationalInventory(options = {}) {
       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"))));
+  artifacts.push(...mcpArtifactsFromJson("cursor", readJson(join42(home, ".cursor", "mcp.json"))));
+  artifacts.push(...codexMcpArtifacts(readText(join42(codexHome, "config.toml"))));
   const projectRoots = discoveredProjectRoots(
     claudeJson,
     options.currentDirectory ?? process.cwd(),
@@ -16798,11 +18739,11 @@ function collectOperationalInventory(options = {}) {
     const scopeHash = sha256(projectRoot).slice(0, 16);
     artifacts.push(...mcpArtifactsFromJson(
       "claude_code",
-      readJson(join37(projectRoot, ".mcp.json")),
+      readJson(join42(projectRoot, ".mcp.json")),
       `project:${scopeHash}`
     ));
-    const cursorProjectConfig = join37(projectRoot, ".cursor", "mcp.json");
-    if (resolve5(cursorProjectConfig) !== resolve5(join37(home, ".cursor", "mcp.json"))) {
+    const cursorProjectConfig = join42(projectRoot, ".cursor", "mcp.json");
+    if (resolve5(cursorProjectConfig) !== resolve5(join42(home, ".cursor", "mcp.json"))) {
       artifacts.push(...mcpArtifactsFromJson(
         "cursor",
         readJson(cursorProjectConfig),
@@ -16813,7 +18754,7 @@ function collectOperationalInventory(options = {}) {
   for (const managedPath of claudeManagedMcpConfigCandidates(targetPlatform)) {
     artifacts.push(...mcpArtifactsFromJson("claude_code", readJson(managedPath), "managed"));
   }
-  const desktopConfigPath = claudeDesktopConfigCandidates(home, targetPlatform).find((path) => existsSync38(path));
+  const desktopConfigPath = claudeDesktopConfigCandidates(home, targetPlatform).find((path) => existsSync42(path));
   if (desktopConfigPath) {
     const desktopConfig = readJson(desktopConfigPath);
     harnesses.push({
@@ -16824,7 +18765,7 @@ function collectOperationalInventory(options = {}) {
     });
     artifacts.push(...mcpArtifactsFromJson("claude_desktop", desktopConfig));
   }
-  const claudeSettings = readJson(join37(home, ".claude", "settings.json"));
+  const claudeSettings = readJson(join42(home, ".claude", "settings.json"));
   if (claudeSettings?.enabledPlugins && typeof claudeSettings.enabledPlugins === "object") {
     for (const [name, enabled] of Object.entries(claudeSettings.enabledPlugins)) {
       artifacts.push({
@@ -16838,10 +18779,10 @@ function collectOperationalInventory(options = {}) {
       });
     }
   }
-  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")));
+  artifacts.push(...skillArtifacts("claude_code", join42(home, ".claude", "skills")));
+  artifacts.push(...skillArtifacts("cursor", join42(home, ".cursor", "skills")));
+  artifacts.push(...skillArtifacts("codex", join42(codexHome, "skills")));
+  artifacts.push(...cursorExtensionArtifacts(join42(home, ".cursor", "extensions")));
   const uniqueArtifacts = /* @__PURE__ */ new Map();
   for (const artifact of artifacts) {
     const key = `${artifact.harness || "global"}:${artifact.type}:${artifact.canonical_id}`;
@@ -16859,7 +18800,7 @@ function collectOperationalInventory(options = {}) {
       install_id: identity.installation_id,
       hostname_hash: pseudonymousHostnameHash(identity.installation_id, hostname2()),
       platform: targetPlatform,
-      os_version: release(),
+      os_version: release2(),
       arch: arch(),
       cli_version: cliVersion(),
       node_version: process.version,
@@ -16894,22 +18835,22 @@ __export(sync_exports2, {
   syncOperationalInventoryDetached: () => syncOperationalInventoryDetached
 });
 import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn10 } from "child_process";
 import {
-  existsSync as existsSync39,
-  mkdirSync as mkdirSync21,
-  readFileSync as readFileSync37,
+  existsSync as existsSync43,
+  mkdirSync as mkdirSync25,
+  readFileSync as readFileSync40,
   renameSync as renameSync10,
-  writeFileSync as writeFileSync26
+  writeFileSync as writeFileSync30
 } from "fs";
-import { homedir as homedir38 } from "os";
-import { dirname as dirname10, join as join38 } from "path";
+import { homedir as homedir44 } from "os";
+import { dirname as dirname13, join as join43 } from "path";
 function syncStatePath() {
-  return process.env.SYNKRO_INVENTORY_SYNC_STATE_PATH || join38(homedir38(), ".synkro", "inventory-sync.json");
+  return process.env.SYNKRO_INVENTORY_SYNC_STATE_PATH || join43(homedir44(), ".synkro", "inventory-sync.json");
 }
 function readState(path = syncStatePath()) {
   try {
-    const parsed = JSON.parse(readFileSync37(path, "utf8"));
+    const parsed = JSON.parse(readFileSync40(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -16917,9 +18858,9 @@ function readState(path = syncStatePath()) {
 }
 function writeState(state, path = syncStatePath()) {
   try {
-    mkdirSync21(dirname10(path), { recursive: true, mode: 448 });
+    mkdirSync25(dirname13(path), { recursive: true, mode: 448 });
     const temp = `${path}.${process.pid}.tmp`;
-    writeFileSync26(temp, JSON.stringify(state, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+    writeFileSync30(temp, JSON.stringify(state, null, 2) + "\n", { encoding: "utf8", mode: 384 });
     renameSync10(temp, path);
   } catch {
   }
@@ -16932,10 +18873,10 @@ function shouldSyncInventory(state, now = Date.now(), target) {
   return !Number.isFinite(lastAttempt) || lastAttempt <= 0 || now - lastAttempt >= FAILURE_RETRY_MS;
 }
 function readConfig() {
-  const path = join38(homedir38(), ".synkro", "config.env");
+  const path = join43(homedir44(), ".synkro", "config.env");
   const out = {};
   try {
-    for (const rawLine of readFileSync37(path, "utf8").split("\n")) {
+    for (const rawLine of readFileSync40(path, "utf8").split("\n")) {
       const line = rawLine.trim();
       if (!line || line.startsWith("#")) continue;
       const index = line.indexOf("=");
@@ -16974,7 +18915,7 @@ function resolveInventoryGateway(raw) {
 }
 async function loadToken() {
   try {
-    const durable = readFileSync37(join38(homedir38(), ".synkro", ".mcp-jwt"), "utf8").trim();
+    const durable = readFileSync40(join43(homedir44(), ".synkro", ".mcp-jwt"), "utf8").trim();
     if (durable) return durable;
   } catch {
   }
@@ -17092,8 +19033,8 @@ function syncOperationalInventoryDetached() {
   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"], {
+    if (!script || !existsSync43(script)) return;
+    const child = spawn10(process.execPath, [script, "inventory-sync", "--detached"], {
       detached: true,
       stdio: "ignore",
       env: { ...process.env, SYNKRO_INVENTORY_DETACHED: "1" }
@@ -17116,14 +19057,15 @@ var init_sync2 = __esm({
 });
 
 // cli/bootstrap.js
-import { readFileSync as readFileSync38, existsSync as existsSync40 } from "fs";
+import { readFileSync as readFileSync41, existsSync as existsSync44 } from "fs";
 import { resolve as resolve6 } from "path";
+process.title = "synkro";
 var envCandidates = [
   resolve6(process.env.HOME ?? "", ".synkro", "config.env")
 ];
 for (const envPath of envCandidates) {
-  if (!existsSync40(envPath)) continue;
-  const envContent = readFileSync38(envPath, "utf-8");
+  if (!existsSync44(envPath)) continue;
+  const envContent = readFileSync41(envPath, "utf-8");
   for (const line of envContent.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
@@ -17140,7 +19082,7 @@ var subArgs = args.slice(1);
 var isDetachedChild = process.env.SYNKRO_TELEMETRY_DETACHED === "1";
 var FLUSH_SKIP = /* @__PURE__ */ new Set(["grade", "inventory-sync", "version", "--version", "-v", "help", "--help", "-h", ""]);
 function printVersion() {
-  console.log("1.10.3");
+  console.log("1.10.4");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents