@synkro-sh/cli 1.10.9 → 1.10.11

package/dist/bootstrap.js

@@ -147,7 +147,7 @@ function getIdentity() {
   if (cached2) return cached2;
   let cliVersion2 = "0.0.0";
   try {
-    cliVersion2 = "1.10.9";
+    cliVersion2 = "1.10.11";
   } catch {
   }
   const creds = loadCredentialsIdentity();
@@ -1645,10 +1645,9 @@ function installCCHooks(settingsPath, config) {
       {
         type: "command",
         command: config.cvePrecheckScriptPath,
-        // 15s: the on-findings VEX grade fans out across the warm pool; single-package
-        // edits finish in ~5s, but a multi-package edit (many CVEs) can approach ~10s,
-        // so 15 gives comfortable headroom. Only runs when a real vuln is present.
-        timeout: 15
+        // Only a confirmed vulnerable runtime dependency reaches VEX triage. Codex can
+        // take 13-17s for a valid answer, so match the bounded 25s gate plus its margin.
+        timeout: 30
       },
       // skill-judge — its OWN system-message block, parallel with edit-precheck.
       ...config.skillJudgeScriptPath ? [{
@@ -1972,7 +1971,7 @@ function installCursorHooks(hooksJsonPath, config) {
     matcher: "Write|Edit|StrReplace|MultiEdit|NotebookEdit|edit_file|reapply|edit_notebook|ApplyPatch|apply_patch"
   });
   pushCcHook(h, "preToolUse", config.cvePrecheckScriptPath, {
-    timeout: 10,
+    timeout: 30,
     matcher: "Write|Edit|StrReplace|MultiEdit|NotebookEdit|edit_file|reapply|edit_notebook|ApplyPatch|apply_patch"
   });
   pushCcHook(h, "preToolUse", config.agentJudgeScriptPath, {
@@ -2204,7 +2203,7 @@ function installCodexHooks(hooksJsonPath, config) {
   push(h, "PreToolUse", [
     cmd(config.editPrecheckScriptPath, 50, "Reviewing edit"),
     cmd(config.cwePrecheckScriptPath, 50),
-    cmd(config.cvePrecheckScriptPath, 15),
+    cmd(config.cvePrecheckScriptPath, 30),
     ...config.skillJudgeScriptPath ? [cmd(config.skillJudgeScriptPath, 50)] : []
   ], M_EDIT);
   push(h, "PostToolUse", [
@@ -7934,7 +7933,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.9";
+      if (true) return "1.10.11";
       try {
         const pkg = JSON.parse(readFileSync17(new URL("../../package.json", import.meta.url), "utf8"));
         if (pkg.version) return pkg.version;
@@ -8994,7 +8993,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle2(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle2(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle2(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle2("1.10.9")}`
+    `SYNKRO_VERSION=${shellQuoteSingle2("1.10.11")}`
   ];
   if (safeSynkroBin) lines2.push(`SYNKRO_CLI_BIN=${shellQuoteSingle2(safeSynkroBin)}`);
   if (safeUserId) lines2.push(`SYNKRO_USER_ID=${shellQuoteSingle2(safeUserId)}`);
@@ -9741,7 +9740,7 @@ async function installCommand(opts = {}) {
   await setTelemetryState({ enabled: true, remoteFlushEnabled: telemetryConsent });
   emit("install", {
     phase: "started",
-    cli_version_to: "1.10.9",
+    cli_version_to: "1.10.11",
     agents_detected: agents.map((a) => a.kind),
     with_github: false,
     with_local_cc: false,
@@ -15166,7 +15165,6 @@ async function styleOuterSession(bootPath, repoCwd, sidebarWidth) {
   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 = [
-    ["set-option", "-t", UI_SESSION, "-q", "@synkro_build", buildStamp(bootPath)],
     // 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".
@@ -15197,21 +15195,86 @@ async function styleOuterSession(bootPath, repoCwd, sidebarWidth) {
     // 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]);
-  for (const argv of buildClipboardBindings(UI_SESSION)) await run(HOST, argv);
+  for (const argv of style) {
+    if (!(await run(HOST, ["tmux", ...argv])).ok) return false;
+  }
+  for (const argv of buildClipboardBindings(UI_SESSION)) {
+    if (!(await run(HOST, argv)).ok) return false;
+  }
+  return true;
 }
 function parseUiPanes(output) {
-  return String(output || "").split("\n").map((line) => line.split("|")).filter((cols) => cols.length >= 4).map(([window, pane, width, ...command]) => ({
+  return String(output || "").split("\n").map((line) => line.split("|")).filter((cols) => cols.length >= 7).map(([window, pane, width, dead, remain, cwd, ...command]) => ({
     window,
     pane,
     width: Number(width) || 0,
+    dead: dead === "1",
+    remain: remain === "on",
+    cwd,
     command: command.join("|")
   })).filter((row2) => Boolean(row2.window && row2.pane));
 }
-async function refreshUiShell(bootPath, repoCwd) {
-  const expected = buildStamp(bootPath);
-  const current = await run(HOST, ["tmux", "show-options", "-t", UI_SESSION, "-v", "@synkro_build"]);
-  if (current.ok && current.stdout.trim() === expected) return;
+async function ensureUiCenterPane(options) {
+  const listed = await run(HOST, [
+    "tmux",
+    "list-panes",
+    "-t",
+    options.sidebarPane,
+    "-F",
+    "#{pane_id}|#{pane_dead}|#{remain-on-exit}|#{pane_start_command}"
+  ]);
+  if (!listed.ok) return { ok: false, pane: "", created: false, recovered: false };
+  const rows = listed.stdout.split("\n").map((line) => line.split("|")).filter((cols) => cols.length >= 4).map(([pane, dead, remain, ...command]) => ({
+    pane,
+    dead: dead === "1",
+    remain: remain === "on",
+    command: command.join("|")
+  }));
+  let center = rows.find((row2) => row2.pane !== options.sidebarPane);
+  let created = false;
+  if (!center) {
+    const split = await run(HOST, [
+      "tmux",
+      "split-window",
+      "-h",
+      "-t",
+      options.sidebarPane,
+      "-c",
+      options.cwd,
+      "-P",
+      "-F",
+      "#{pane_id}",
+      "tail -f /dev/null"
+    ]);
+    const pane = split.stdout.trim();
+    if (!split.ok || !pane) return { ok: false, pane: "", created: false, recovered: false };
+    center = { pane, dead: false, remain: false, command: "tail -f /dev/null" };
+    created = true;
+  }
+  const kept = await run(HOST, buildKeepPaneAfterExit(center.pane));
+  if (!kept.ok) return { ok: false, pane: center.pane, created, recovered: false };
+  const recovered = created || center.dead;
+  if (recovered) {
+    const command = options.terminalCommand === void 0 ? makeTerminalCommand(options.bootPath) : options.terminalCommand;
+    const respawn = ["tmux", "respawn-pane", "-k", "-t", center.pane, "-c", options.cwd];
+    if (command) respawn.push(command);
+    const restored = await run(HOST, respawn);
+    if (!restored.ok) return { ok: false, pane: center.pane, created, recovered: false };
+    const spaceName = options.cwd.split("/").filter(Boolean).pop() || "space";
+    const metadata = [
+      ["tmux", "set-option", "-t", center.pane, "-w", "-q", "@synkro_agent", ""],
+      ["tmux", "set-option", "-t", center.pane, "-w", "-q", "@synkro_cwd", options.cwd],
+      ["tmux", "set-option", "-t", center.pane, "-w", "-q", "@synkro_kind", "terminal"],
+      ["tmux", "set-option", "-t", center.pane, "-w", "automatic-rename", "off"],
+      ["tmux", "rename-window", "-t", center.pane, tabTitle("terminal", spaceName)]
+    ];
+    for (const argv of metadata) {
+      if (!(await run(HOST, argv)).ok) return { ok: false, pane: center.pane, created, recovered: false };
+    }
+  }
+  return { ok: true, pane: center.pane, created, recovered };
+}
+async function reconcileUiShell(bootPath, repoCwd, options = {}) {
   const listed = await run(HOST, [
     "tmux",
     "list-panes",
@@ -15219,18 +15282,64 @@ async function refreshUiShell(bootPath, repoCwd) {
     "-t",
     UI_SESSION,
     "-F",
-    "#{window_id}|#{pane_id}|#{pane_width}|#{pane_start_command}"
+    "#{window_id}|#{pane_id}|#{pane_width}|#{pane_dead}|#{remain-on-exit}|#{@synkro_cwd}|#{pane_start_command}"
   ]);
-  if (!listed.ok) return;
+  if (!listed.ok) return { ok: false, changed: false };
   const panes = parseUiPanes(listed.stdout);
   const sidebars = panes.filter((row2) => row2.command.includes("--sidebar"));
-  if (sidebars.length === 0) return;
-  await styleOuterSession(bootPath, repoCwd, sidebars[0].width || 30);
+  if (sidebars.length === 0) return { ok: false, changed: false };
+  let changed = false;
   for (const sidebar of sidebars) {
-    const center = panes.find((row2) => row2.window === sidebar.window && row2.pane !== sidebar.pane);
-    if (!center) continue;
-    await run(HOST, ["tmux", "respawn-pane", "-k", "-t", sidebar.pane, sidebarCommand(bootPath, center.pane, repoCwd)]);
+    const previous = panes.find((row2) => row2.window === sidebar.window && row2.pane !== sidebar.pane);
+    const cwd = sidebar.cwd ? sidebar.cwd.startsWith("/") ? sidebar.cwd : join34(repoCwd, sidebar.cwd) : repoCwd;
+    const center = await ensureUiCenterPane({
+      sidebarPane: sidebar.pane,
+      bootPath,
+      cwd,
+      terminalCommand: options.terminalCommand
+    });
+    if (!center.ok) return { ok: false, changed };
+    if (sidebar.cwd !== cwd) {
+      const migrated2 = await run(HOST, ["tmux", "set-option", "-t", sidebar.window, "-w", "-q", "@synkro_cwd", cwd]);
+      if (!migrated2.ok) return { ok: false, changed };
+      changed = true;
+    }
+    const staleBinding = !sidebar.command.includes("SYNKRO_UI_CENTER=" + center.pane + " ");
+    if (options.refreshSidebars || center.recovered || staleBinding) {
+      const rebound = await run(HOST, [
+        "tmux",
+        "respawn-pane",
+        "-k",
+        "-t",
+        sidebar.pane,
+        sidebarCommand(bootPath, center.pane, repoCwd)
+      ]);
+      if (!rebound.ok) return { ok: false, changed };
+      changed = true;
+    }
+    if (!previous?.remain || center.created || center.recovered) changed = true;
   }
+  return { ok: true, changed };
+}
+async function refreshUiShell(bootPath, repoCwd, options = {}) {
+  const expected = buildStamp(bootPath);
+  const current = await run(HOST, ["tmux", "show-options", "-t", UI_SESSION, "-v", "@synkro_build"]);
+  const buildChanged = !current.ok || current.stdout.trim() !== expected;
+  if (buildChanged) {
+    const width = await currentWindowColumns(UI_SESSION);
+    if (!await styleOuterSession(bootPath, repoCwd, Number(sidebarColumns(width)))) return false;
+  }
+  const reconciled = await reconcileUiShell(bootPath, repoCwd, {
+    terminalCommand: options.terminalCommand,
+    refreshSidebars: buildChanged
+  });
+  if (!reconciled.ok) return false;
+  if (reconciled.changed && options.persistLayout !== false) await snapshotTabs();
+  if (buildChanged) {
+    const stamped = await run(HOST, ["tmux", "set-option", "-t", UI_SESSION, "-q", "@synkro_build", expected]);
+    if (!stamped.ok) return false;
+  }
+  return true;
 }
 async function buildTab(bootPath, repoCwd, spec) {
   await run(HOST, ["tmux", "set-option", "-g", "history-limit", "50000"]);
@@ -15238,8 +15347,20 @@ async function buildTab(bootPath, repoCwd, spec) {
   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 create = [
+      "tmux",
+      "new-session",
+      "-d",
+      "-s",
+      UI_SESSION,
+      "-x",
+      cols,
+      "-y",
+      rows,
+      "-c",
+      spec.cwd,
+      "tail -f /dev/null"
+    ];
     const made = await run(HOST, create);
     if (!made.ok) {
       throw new Error("tmux new-session failed: " + made.stderr.trim());
@@ -15249,14 +15370,26 @@ async function buildTab(bootPath, repoCwd, spec) {
     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 create = [
+      "tmux",
+      "new-window",
+      "-t",
+      UI_SESSION,
+      "-P",
+      "-F",
+      "#{window_id}",
+      "-c",
+      spec.cwd,
+      "tail -f /dev/null"
+    ];
     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));
+  if (!await styleOuterSession(bootPath, repoCwd, Number(sidebarCols))) {
+    throw new Error("tmux outer session styling failed");
+  }
   const split = await run(HOST, [
     "tmux",
     "split-window",
@@ -15271,18 +15404,35 @@ async function buildTab(bootPath, repoCwd, spec) {
     "tail -f /dev/null"
   ]);
   const sidebarPane = split.stdout.trim();
+  if (!split.ok || !sidebarPane) throw new Error("tmux sidebar split failed: " + split.stderr.trim());
   const panes = await run(HOST, ["tmux", "list-panes", "-t", windowTarget, "-F", "#{pane_id}"]);
   const centerPane = panes.stdout.split("\n").map((line) => line.trim()).filter(Boolean).find((id) => id !== sidebarPane) || "";
-  await run(HOST, buildKeepPaneAfterExit(centerPane));
+  if (!centerPane) throw new Error("tmux center pane was not created");
+  const kept = await run(HOST, buildKeepPaneAfterExit(centerPane));
+  if (!kept.ok) throw new Error("tmux center durability failed: " + kept.stderr.trim());
   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 sidebarStarted = await run(HOST, [
+    "tmux",
+    "respawn-pane",
+    "-k",
+    "-t",
+    sidebarPane,
+    sidebarCommand(bootPath, centerPane, repoCwd)
+  ]);
+  if (!sidebarStarted.ok) throw new Error("tmux sidebar start failed: " + sidebarStarted.stderr.trim());
+  const centerStart = ["tmux", "respawn-pane", "-k", "-t", centerPane, "-c", spec.cwd];
+  if (spec.center) centerStart.push(spec.center);
+  const centerStarted = await run(HOST, centerStart);
+  if (!centerStarted.ok) throw new Error("tmux center start failed: " + centerStarted.stderr.trim());
   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]);
+  const stamped = await run(HOST, ["tmux", "set-option", "-t", UI_SESSION, "-q", "@synkro_build", buildStamp(bootPath)]);
+  if (!stamped.ok) throw new Error("tmux build stamp failed: " + stamped.stderr.trim());
   await snapshotTabs();
   await run(HOST, ["tmux", "select-pane", "-t", spec.focus === "sidebar" ? sidebarPane : centerPane]);
 }
@@ -15325,7 +15475,9 @@ async function launchUi(bootPath, repoCwd) {
   if (!await uiSessionExists()) {
     await buildTab(bootPath, repoCwd, { cwd: repoCwd, center: makeTerminalCommand(bootPath), focus: "sidebar" });
   } else {
-    await refreshUiShell(bootPath, repoCwd);
+    if (!await refreshUiShell(bootPath, repoCwd)) {
+      throw new Error("Synkro UI could not repair its tmux layout");
+    }
   }
   await pruneCollapsedClients();
   return runInherit(process.env.TMUX ? ["tmux", "switch-client", "-t", UI_SESSION] : ["tmux", "attach-session", "-t", UI_SESSION]);
@@ -15798,8 +15950,11 @@ var init_awake = __esm({
 function runnerFor(backend) {
   return backend === "container" ? { kind: "container", container: CONTAINER_NAME2 } : { kind: "host" };
 }
+function hasLiveAgentCenter(paneOutput, session) {
+  return String(paneOutput || "").split("\n").map((line) => line.split("|")).some(([dead, ...command]) => dead === "0" && !command.join("|").includes("--sidebar") && command.join("|").includes(session));
+}
 async function runSidebar() {
-  const centerPane = process.env.SYNKRO_UI_CENTER || "";
+  let 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();
@@ -15967,53 +16122,114 @@ async function runSidebar() {
     const agent = state.agents[state.agentIndex];
     if (agent) await showAgent(agent);
   }
+  async function resolveCenterPane(cwd) {
+    if (!ownPane || !cwd) return "";
+    const resolved = await ensureUiCenterPane({ sidebarPane: ownPane, bootPath, cwd });
+    if (!resolved.ok) {
+      state.message = "could not restore this tab";
+      return "";
+    }
+    centerPane = resolved.pane;
+    if (resolved.recovered) {
+      state.viewing = "";
+      await snapshotTabs();
+      stripWidth = -1;
+      await syncChipStrip();
+    }
+    return centerPane;
+  }
   async function showWorkspaceTerminal(cwd) {
-    if (!centerPane || !cwd) return;
+    const pane = await resolveCenterPane(cwd);
+    if (!pane) return false;
     const command = makeTerminalCommand(bootPath);
-    const argv = ["tmux", "respawn-pane", "-k", "-t", centerPane, "-c", cwd];
+    const argv = ["tmux", "respawn-pane", "-k", "-t", pane, "-c", cwd];
     if (command) argv.push(command);
     const respawned = await run(host, argv);
     if (!respawned.ok) {
       state.message = "could not restore workspace terminal";
-      return;
+      return false;
     }
     const spaceName = cwd.split("/").filter(Boolean).pop() || "space";
-    await run(host, ["tmux", "set-option", "-t", centerPane, "-w", "-u", "@synkro_agent"]);
-    await run(host, ["tmux", "set-option", "-t", centerPane, "-w", "-q", "@synkro_cwd", cwd]);
-    await run(host, ["tmux", "set-option", "-t", centerPane, "-w", "-q", "@synkro_kind", "terminal"]);
-    await run(host, ["tmux", "rename-window", "-t", centerPane, tabTitle("terminal", spaceName)]);
+    const metadata = [
+      ["tmux", "set-option", "-t", pane, "-w", "-q", "@synkro_agent", ""],
+      ["tmux", "set-option", "-t", pane, "-w", "-q", "@synkro_cwd", cwd],
+      ["tmux", "set-option", "-t", pane, "-w", "-q", "@synkro_kind", "terminal"],
+      ["tmux", "rename-window", "-t", pane, tabTitle("terminal", spaceName)]
+    ];
+    for (const commandArgv of metadata) {
+      if (!(await run(host, commandArgv)).ok) {
+        state.message = "could not update this tab";
+        return false;
+      }
+    }
     state.viewing = "";
     await snapshotTabs();
+    return true;
   }
-  async function showAgent(agent) {
-    if (!centerPane) return;
-    if (agent.status === "offline") {
-      await restoreSelected();
-      return;
-    }
+  async function markAgentViewed(agent) {
     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;
+  }
+  async function showAgent(agent) {
+    if (agent.status === "offline") {
+      await restoreSelected();
+      return false;
+    }
     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;
+      const holderPanes = await run(host, [
+        "tmux",
+        "list-panes",
+        "-t",
+        holder[0],
+        "-F",
+        "#{pane_dead}|#{pane_start_command}"
+      ]);
+      const liveCenter = holderPanes.ok && hasLiveAgentCenter(holderPanes.stdout, agent.session);
+      if (liveCenter) {
+        const selected = await run(host, ["tmux", "select-window", "-t", holder[0]]);
+        if (selected.ok) {
+          await markAgentViewed(agent);
+          state.message = agent.name;
+          return true;
+        }
+      }
+      await run(host, ["tmux", "set-option", "-t", holder[0], "-w", "-q", "@synkro_agent", ""]);
     }
+    const pane = await resolveCenterPane(agent.space || selectedSpace()?.path || repoCwd);
+    if (!pane) return false;
     await run(runnerFor(agent.backend), buildEnableMouse(agent.session));
     for (const argv of buildClipboardBindings(agent.session)) {
       await run(runnerFor(agent.backend), argv);
     }
     const command = buildCenterAttachCommand(runnerFor(agent.backend), agent.session);
-    await run(host, ["tmux", "respawn-pane", "-k", "-t", centerPane, command]);
+    const attached = await run(host, ["tmux", "respawn-pane", "-k", "-t", pane, command]);
+    if (!attached.ok) {
+      state.message = "could not open " + agent.name;
+      await showWorkspaceTerminal(agent.space || selectedSpace()?.path || repoCwd);
+      return false;
+    }
     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]);
+    const metadata = [
+      ["tmux", "set-option", "-t", pane, "-w", "-q", "@synkro_agent", agent.session],
+      ["tmux", "set-option", "-t", pane, "-w", "-q", "@synkro_cwd", agent.space || repoCwd],
+      ["tmux", "set-option", "-t", pane, "-w", "-q", "@synkro_kind", agent.harness],
+      ["tmux", "rename-window", "-t", pane, tabTitle(agent.harness, where)]
+    ];
+    for (const commandArgv of metadata) {
+      if (!(await run(host, commandArgv)).ok) {
+        state.message = "could not update " + agent.name + " tab";
+        await showWorkspaceTerminal(agent.space || selectedSpace()?.path || repoCwd);
+        return false;
+      }
+    }
+    await markAgentViewed(agent);
     await snapshotTabs();
     state.message = "attached " + agent.name;
+    return true;
   }
   async function confirmKillAgent() {
     const agent = state.agents[state.agentIndex];
@@ -16024,7 +16240,8 @@ async function runSidebar() {
     if (allAgents.some((candidate) => candidate.session === agent.session && candidate.status !== "offline")) return;
     state.message = "closed " + agent.name;
     if (!wasViewing) return;
-    await showWorkspaceTerminal(agent.space || selectedSpace()?.path || repoCwd);
+    const restored = await showWorkspaceTerminal(agent.space || selectedSpace()?.path || repoCwd);
+    if (!restored) return;
     const successor = nextLiveAgent(allAgents, agent.repo || "");
     if (successor) await showAgent(successor);
   }
@@ -16940,6 +17157,42 @@ var init_dialog = __esm({
   }
 });
 
+// cli/harness/events.ts
+function fixPollIds(raw) {
+  const text = String(raw || "");
+  const ids = [
+    ...Array.from(text.matchAll(FIX_POLL_MARKERS), (match) => match[1]),
+    ...Array.from(text.matchAll(LEGACY_FIX_POLL_MARKERS), (match) => match[1])
+  ];
+  return Array.from(new Set(ids.filter(Boolean)));
+}
+function fixPollId(raw) {
+  return fixPollIds(raw)[0] || "";
+}
+function cleanGuardText(raw) {
+  return String(raw || "").replace(FIX_POLL_MARKERS, "").replace(/\n*\s*SYNKRO FIX POLL[\s\S]*$/i, "").replace(/\n?\d{4}-\d\d-\d\dT[^\n]*\sERROR\s+codex_core::tools::router:[^\n]*/gi, "").replace(/\s*Checking command\s*$/i, "").trim();
+}
+function blockReason(raw) {
+  const text = cleanGuardText(raw);
+  if (!text) return "blocked by policy";
+  const guardAt = text.lastIndexOf("Guard:");
+  if (guardAt >= 0) return text.slice(guardAt + "Guard:".length).trim();
+  const afterTag = text.match(/\[synkro:[^\]]*\]\s*(.+)/is);
+  if (afterTag) return afterTag[1].trim();
+  const afterHook = text.match(/blocked by a hook:\s*(.+)/is);
+  if (afterHook) return afterHook[1].trim();
+  return text;
+}
+var BLOCK_MARKER, FIX_POLL_MARKERS, LEGACY_FIX_POLL_MARKERS;
+var init_events = __esm({
+  "cli/harness/events.ts"() {
+    "use strict";
+    BLOCK_MARKER = /blocked by a hook|\[synkro:/i;
+    FIX_POLL_MARKERS = /\[synkro:fix-poll\s+item_id=\\*["']?([A-Za-z0-9_-]+)\\*["']?\s*\]/gi;
+    LEGACY_FIX_POLL_MARKERS = /SYNKRO FIX POLL\s*\(item_id=([A-Za-z0-9_-]+)\)/gi;
+  }
+});
+
 // cli/harness/render.ts
 function spinnerFrame(tick) {
   return SPINNER[Math.abs(tick) % SPINNER.length];
@@ -17001,10 +17254,11 @@ function renderEvent(event, width = 100) {
     }
     case "tool-end": {
       if (event.blocked) {
+        const reason = cleanGuardText(event.reason);
         return [
           S2.panel + S2.blocked + "  \u29C9 Blocked" + S2.reset + S2.panel + S2.secondary + "  " + clip3(terminalText(event.target), body - 21) + S2.reset,
-          ...wrap(terminalText(event.reason), body - 6).map((line, index) => index === 0 ? S2.blocked + "    " + ELBOW + " " + S2.reset + S2.rule + line + S2.reset : S2.rule + "      " + line + S2.reset),
-          ...wrap(blockNextStep(event.reason), body - 6).map((line) => S2.secondary + "      " + line + S2.reset)
+          ...wrap(terminalText(reason), body - 6).map((line, index) => index === 0 ? S2.blocked + "    " + ELBOW + " " + S2.reset + S2.rule + line + S2.reset : S2.rule + "      " + line + S2.reset),
+          ...wrap(blockNextStep(reason), body - 6).map((line) => S2.secondary + "      " + line + S2.reset)
         ];
       }
       const timing = event.durationMs == null ? "" : " \xB7 " + seconds(event.durationMs);
@@ -17053,6 +17307,7 @@ var ESC2, color, S2, CLEAR_LINE, BULLET, ELBOW, SPINNER, TOOL_LABEL;
 var init_render2 = __esm({
   "cli/harness/render.ts"() {
     "use strict";
+    init_events();
     ESC2 = "\x1B[";
     color = (hex, plane = 38) => {
       const [r, g, b] = hex.match(/../g).map((part) => Number.parseInt(part, 16));
@@ -17107,35 +17362,6 @@ var init_composer = __esm({
   }
 });
 
-// cli/harness/events.ts
-function fixPollId(raw) {
-  const text = String(raw || "");
-  return FIX_POLL_MARKER.exec(text)?.[1] || LEGACY_FIX_POLL_MARKER.exec(text)?.[1] || "";
-}
-function cleanGuardText(raw) {
-  return String(raw || "").replace(FIX_POLL_MARKER, "").replace(/\n*\s*SYNKRO FIX POLL[\s\S]*$/i, "").replace(/\n?\d{4}-\d\d-\d\dT[^\n]*\sERROR\s+codex_core::tools::router:[^\n]*/gi, "").replace(/\s*Checking command\s*$/i, "").trim();
-}
-function blockReason(raw) {
-  const text = cleanGuardText(raw);
-  if (!text) return "blocked by policy";
-  const guardAt = text.lastIndexOf("Guard:");
-  if (guardAt >= 0) return text.slice(guardAt + "Guard:".length).trim();
-  const afterTag = text.match(/\[synkro:[^\]]*\]\s*(.+)/is);
-  if (afterTag) return afterTag[1].trim();
-  const afterHook = text.match(/blocked by a hook:\s*(.+)/is);
-  if (afterHook) return afterHook[1].trim();
-  return text;
-}
-var BLOCK_MARKER, FIX_POLL_MARKER, LEGACY_FIX_POLL_MARKER;
-var init_events = __esm({
-  "cli/harness/events.ts"() {
-    "use strict";
-    BLOCK_MARKER = /blocked by a hook|\[synkro:/i;
-    FIX_POLL_MARKER = /\[synkro:fix-poll\s+item_id=\\?["']?([A-Za-z0-9_-]+)\\?["']?\]/i;
-    LEGACY_FIX_POLL_MARKER = /SYNKRO FIX POLL\s*\(item_id=([A-Za-z0-9_-]+)\)/i;
-  }
-});
-
 // cli/harness/changes.ts
 import { lstatSync as lstatSync2, readFileSync as readFileSync33, readlinkSync } from "fs";
 import { resolve as resolve6, relative } from "path";
@@ -17419,6 +17645,7 @@ function parseCursorLine(line, streamPartial = false) {
         blocked,
         reason: rejected ? blocked ? blockReason(rawReason) : rawReason || "rejected" : "",
         pollId: blocked ? fixPollId(rawReason) : "",
+        pollIds: blocked ? fixPollIds(rawReason) : [],
         exitCode: success ? Number(success.exitCode ?? 0) : null,
         output: String(success?.stdout || success?.stderr || ""),
         fileChanges: completedFileChanges(body)
@@ -17761,6 +17988,11 @@ var init_run = __esm({
 // cli/harness/codex.ts
 import { spawn as spawn10 } from "child_process";
 import { createInterface as createInterface6 } from "readline";
+function codexStderrNotice(raw, initialized) {
+  const text = String(raw || "").trim();
+  if (!text || initialized) return "";
+  return /fatal|panic|authentication failed|not logged in/i.test(text) ? text.split("\n")[0].slice(0, 300) : "";
+}
 function stringify(value) {
   if (typeof value === "string") return value;
   try {
@@ -17843,6 +18075,7 @@ function codexEvents(message) {
       blocked,
       reason: blocked ? blockReason(raw || status) : "",
       pollId: blocked ? fixPollId(raw) : "",
+      pollIds: blocked ? fixPollIds(raw) : [],
       exitCode: typeof item.exitCode === "number" ? item.exitCode : null,
       output: raw,
       durationMs: typeof item.durationMs === "number" ? item.durationMs : null,
@@ -17864,6 +18097,7 @@ function codexEvents(message) {
       exitCode: null,
       output: reason,
       pollId: fixPollId(reason),
+      pollIds: fixPollIds(reason),
       durationMs: typeof run2.durationMs === "number" ? run2.durationMs : null
     }];
   }
@@ -17898,6 +18132,7 @@ var init_codex = __esm({
       cwd;
       resumeId;
       child = null;
+      initialized = false;
       nextId = 1;
       pending = /* @__PURE__ */ new Map();
       onEvent = null;
@@ -17974,7 +18209,7 @@ var init_codex = __esm({
           }
         });
         this.child.stderr.on("data", (chunk) => {
-          const message = String(chunk || "").trim();
+          const message = codexStderrNotice(String(chunk || ""), this.initialized);
           if (message) this.onEvent?.({ type: "notice", text: message });
         });
         this.child.once("exit", (code) => {
@@ -17985,6 +18220,7 @@ var init_codex = __esm({
         });
         await this.request("initialize", { clientInfo: { name: "synkro-terminal", title: "Synkro", version: "1" }, capabilities: { experimentalApi: true } });
         this.notify("initialized");
+        this.initialized = true;
         try {
           const event = codexAccountUsageEvent(await this.request("account/rateLimits/read", null, 4e3));
           if (event) this.accountUsage = event;
@@ -18081,6 +18317,7 @@ var init_screen = __esm({
       cwd;
       write;
       transcript = [];
+      inlinePanel = [];
       draft = "";
       input = "";
       selectionAnchor = null;
@@ -18122,6 +18359,17 @@ var init_screen = __esm({
         this.selectionFocus = null;
         this.draw();
       }
+      setInlinePanel(lines2) {
+        this.inlinePanel = [...lines2];
+        this.scrollOffset = 0;
+        this.draw();
+      }
+      commitInlinePanel(lines2) {
+        this.inlinePanel = [];
+        this.transcript.push(...lines2);
+        this.scrollOffset = 0;
+        this.draw();
+      }
       selectionRange() {
         if (this.selectionAnchor === null || this.selectionFocus === null || this.selectionAnchor === this.selectionFocus) return null;
         return [Math.min(this.selectionAnchor, this.selectionFocus), Math.max(this.selectionAnchor, this.selectionFocus)];
@@ -18230,7 +18478,7 @@ var init_screen = __esm({
         const status = this.status === "Ready" ? S2.secondary + "  \xB7 Ready" + S2.reset : statusLine({ tick: this.tick, text: this.status, elapsedMs: Date.now() - this.statusSince, width });
         const rule = S2.border + "  " + "\u2500".repeat(inner) + S2.reset;
         const inputRows = this.inputRows(width);
-        const composer = [rule, ...inputRows.map((row2, i) => S2.composer + (i ? "    " : S2.user + "  \u276F ") + this.selectedText(row2) + (i === inputRows.length - 1 ? S2.user + " \u258C" : "") + S2.reset), rule];
+        const composer = this.inlinePanel.length ? [rule] : [rule, ...inputRows.map((row2, i) => S2.composer + (i ? "    " : S2.user + "  \u276F ") + this.selectedText(row2) + (i === inputRows.length - 1 ? S2.user + " \u258C" : "") + S2.reset), rule];
         const usedPercent = this.context ? Math.min(100, Math.round(this.used / this.context * 100)) : null;
         const contextUsage = usedPercent === null ? "\u2014 context" : usedPercent + "% context";
         const resetDate = this.weeklyResetsAt == null ? "" : "  \xB7  " + resetDateFormat.format(new Date(this.weeklyResetsAt * 1e3));
@@ -18241,7 +18489,7 @@ var init_screen = __esm({
         const right = badge + S2.secondary + "  \xB7  " + provider + (this.model ? "  " + cleanOutput(this.model) : "") + "  \xB7  \u29C9 powered by synkro  " + S2.reset + S2.canvas;
         const footer = left + " ".repeat(Math.max(1, width - visible(left) - visible(right))) + right;
         const viewport = Math.max(3, height - composer.length - 2);
-        const fullContent = [...this.transcript, ...draft, status];
+        const fullContent = [...this.transcript, ...draft, ...this.inlinePanel, status];
         const maxScroll = Math.max(0, fullContent.length - viewport);
         const effectiveOffset = Math.min(this.scrollOffset, maxScroll);
         const end = fullContent.length - effectiveOffset;
@@ -18321,24 +18569,31 @@ async function loadFixPoll(itemId, fetchImpl = fetch) {
   const body = await response.json();
   const candidates = Array.isArray(body.candidates) ? body.candidates.filter((candidate) => typeof candidate === "string").slice(0, 8) : [];
   if (!candidates.length || body.status !== "pending") return null;
+  const recommendedIdx = Number.isInteger(body.recommended_idx) && body.recommended_idx >= 0 && body.recommended_idx < candidates.length ? body.recommended_idx : -1;
   return {
     itemId,
     filePath: String(body.file_path || ""),
     ruleId: String(body.rule_id || ""),
-    candidates
+    candidates,
+    recommendedIdx
   };
 }
-async function recordFixPoll(itemId, chosenIdx, fetchImpl = fetch) {
+async function recordFixPoll(itemId, selection, fetchImpl = fetch) {
   const response = await fetchImpl(pollBaseUrl() + "/record", {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify({ item_id: itemId, chosen_idx: chosenIdx })
+    body: JSON.stringify({
+      item_id: itemId,
+      chosen_idx: selection.chosenIdx,
+      custom_response: selection.customResponse || void 0
+    })
   });
   return response.ok;
 }
-function fixPollLines(poll, selected, width = 100) {
+function fixPollLines(poll, selected, width = 100, customResponse = "", editingCustom = false) {
   const max = Math.max(32, width - 10);
-  const choices = [...poll.candidates, "None of the above"];
+  const choices = [...poll.candidates, CUSTOM_CHOICE, NONE_CHOICE];
+  const customIndex = poll.candidates.length;
   const scope = [poll.ruleId, poll.filePath].filter(Boolean).join("  \xB7  ");
   const lines2 = [
     "",
@@ -18348,43 +18603,105 @@ function fixPollLines(poll, selected, width = 100) {
   ];
   choices.forEach((choice, index) => {
     const prefix = index === selected ? S2.user + "  \u276F " : S2.dim + "    ";
-    const text = wrap(index + 1 + ". " + neutralizeTerminalControls(choice), max);
+    const recommendation = index === poll.recommendedIdx ? "Recommended: " : "";
+    const text = wrap(index + 1 + ". " + recommendation + neutralizeTerminalControls(choice), max);
     lines2.push(prefix + (text[0] || "") + S2.reset);
     for (const continuation of text.slice(1)) lines2.push("      " + continuation);
+    if (index === customIndex && editingCustom) {
+      const answer = neutralizeTerminalControls(customResponse);
+      const answerLines = wrap("Your answer: " + answer + "\u258C", max - 2);
+      for (const answerLine of answerLines) lines2.push(S2.user + "      " + answerLine + S2.reset);
+    }
   });
-  lines2.push("", S2.dim + "  \u2191/\u2193 select  \xB7  Enter confirm  \xB7  1-" + choices.length + " choose" + S2.reset);
+  const footer = editingCustom ? "  Type your answer  \xB7  Enter submit  \xB7  Esc back" : "  \u2191/\u2193 select  \xB7  Enter confirm  \xB7  " + (choices.length === 10 ? "1-9/0" : "1-" + choices.length) + " choose";
+  lines2.push("", S2.dim + footer + S2.reset);
+  return lines2;
+}
+function fixPollResultLines(poll, selection, recorded, width = 100) {
+  const max = Math.max(32, width - 14);
+  const scope = [poll.ruleId, poll.filePath].filter(Boolean).join("  \xB7  ");
+  const selected = selection.customResponse ? "Custom answer: " + selection.customResponse : selection.chosenIdx >= 0 && selection.chosenIdx < poll.candidates.length ? "Selected: " + poll.candidates[selection.chosenIdx] : "Selected: " + NONE_CHOICE;
+  const lines2 = [
+    "",
+    (recorded ? S2.ok : S2.blocked) + S2.bold + "  " + (recorded ? "Synkro decision recorded" : "Synkro decision was not recorded") + S2.reset,
+    ...scope ? [S2.dim + "  " + neutralizeTerminalControls(scope) + S2.reset] : []
+  ];
+  const answer = wrap(neutralizeTerminalControls(selected), max);
+  answer.forEach((line, index) => lines2.push((index ? "      " : S2.user + "  \u23BF ") + line + S2.reset));
   return lines2;
 }
 async function pickFixPoll(poll, io = {}) {
   const input = io.input || process.stdin;
   const output = io.output || process.stdout;
-  if (!input.isTTY || !output.isTTY) return -1;
-  let selected = 0;
+  if (!input.isTTY || !output.isTTY) return { chosenIdx: -1, customResponse: "" };
+  const customIndex = poll.candidates.length;
+  const noneIndex = customIndex + 1;
+  const choices = poll.candidates.length + 2;
+  let selected = poll.recommendedIdx >= 0 && poll.recommendedIdx < poll.candidates.length ? poll.recommendedIdx : 0;
+  let customResponse = "";
+  let editingCustom = false;
   let rendered = 0;
   const draw = () => {
-    if (rendered) output.write("\x1B[" + rendered + "A\x1B[J");
-    const lines2 = fixPollLines(poll, selected, Number(output.columns || 100));
-    output.write(lines2.join("\n") + "\n");
-    rendered = lines2.length;
+    const lines2 = fixPollLines(
+      poll,
+      selected,
+      Number(output.columns || 100),
+      customResponse,
+      editingCustom
+    );
+    if (io.render) io.render(lines2);
+    else {
+      if (rendered) output.write("\x1B[" + rendered + "A\x1B[J");
+      output.write(lines2.join("\n") + "\n");
+      rendered = lines2.length;
+    }
   };
-  const choice = await new Promise((resolve9) => {
-    const choices = poll.candidates.length + 1;
+  return new Promise((resolve9) => {
     const wasRaw = Boolean(input.isRaw);
-    const done = (index) => {
+    const done = (selection) => {
       input.off("data", onData);
       if (input.setRawMode) input.setRawMode(wasRaw);
-      resolve9(index === poll.candidates.length ? -1 : index);
+      resolve9(selection);
+    };
+    const confirmSelection = () => {
+      if (selected < customIndex) return done({ chosenIdx: selected, customResponse: "" });
+      if (selected === noneIndex) return done({ chosenIdx: -1, customResponse: "" });
+      editingCustom = true;
+      draw();
     };
     const onData = (chunk) => {
       const key2 = chunk.toString("utf8");
-      if (key2 === "") return done(poll.candidates.length);
-      if (key2 === "\x1B" || key2.toLowerCase() === "n") return done(poll.candidates.length);
-      if (key2 === "\r" || key2 === "\n") return done(selected);
+      if (editingCustom) {
+        if (key2 === "") return done({ chosenIdx: -1, customResponse: "" });
+        if (key2 === "\x1B") {
+          editingCustom = false;
+          draw();
+          return;
+        }
+        const typed = key2.replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "");
+        for (const char of typed) {
+          if (char === "\r" || char === "\n") {
+            const answer = customResponse.trim();
+            if (answer) return done({ chosenIdx: -2, customResponse: answer });
+          } else if (char === "\x7F" || char === "\b") customResponse = customResponse.slice(0, -1);
+          else if (char === "") customResponse = "";
+          else if (char === "") customResponse = customResponse.replace(/\s*\S+\s*$/, "");
+          else if (char >= " " && customResponse.length < MAX_CUSTOM_RESPONSE) customResponse += char;
+        }
+        draw();
+        return;
+      }
+      if (key2 === "") return done({ chosenIdx: -1, customResponse: "" });
+      if (key2 === "\x1B" || key2.toLowerCase() === "n") return done({ chosenIdx: -1, customResponse: "" });
+      if (key2 === "\r" || key2 === "\n") return confirmSelection();
       if (key2 === "\x1B[A" || key2 === "k") selected = (selected - 1 + choices) % choices;
       else if (key2 === "\x1B[B" || key2 === "j") selected = (selected + 1) % choices;
-      else if (/^[1-9]$/.test(key2)) {
-        const index = Number(key2) - 1;
-        if (index < choices) return done(index);
+      else if (/^[0-9]$/.test(key2)) {
+        const index = key2 === "0" ? 9 : Number(key2) - 1;
+        if (index < choices) {
+          selected = index;
+          return confirmSelection();
+        }
       } else return;
       draw();
     };
@@ -18393,25 +18710,30 @@ async function pickFixPoll(poll, io = {}) {
     input.on("data", onData);
     draw();
   });
-  return choice;
 }
 async function resolveFixPolls(events, io = {}) {
-  const ids = Array.from(new Set(events.filter((event) => event.type === "tool-end").map((event) => event.pollId || "").filter(Boolean)));
+  const ids = Array.from(new Set(events.filter((event) => event.type === "tool-end").flatMap((event) => event.pollIds?.length ? event.pollIds : [event.pollId || ""]).filter(Boolean)));
   const recorded = [];
   for (const itemId of ids) {
     const poll = await loadFixPoll(itemId, io.fetchImpl).catch(() => null);
     if (!poll) continue;
-    const chosen = await pickFixPoll(poll, io);
-    const ok = await recordFixPoll(itemId, chosen, io.fetchImpl).catch(() => false);
-    if (ok) recorded.push(chosen);
-    else (io.output || process.stdout).write(S2.blocked + "  Could not record that Synkro decision.\n" + S2.reset);
+    const selection = await pickFixPoll(poll, io);
+    const ok = await recordFixPoll(itemId, selection, io.fetchImpl).catch(() => false);
+    const result = fixPollResultLines(poll, selection, ok, Number((io.output || process.stdout).columns || 100));
+    if (io.commit) io.commit(result);
+    else (io.output || process.stdout).write(result.join("\n") + "\n");
+    if (ok) recorded.push(selection.chosenIdx);
   }
   return recorded;
 }
+var CUSTOM_CHOICE, NONE_CHOICE, MAX_CUSTOM_RESPONSE;
 var init_fixPoll = __esm({
   "cli/harness/fixPoll.ts"() {
     "use strict";
     init_render2();
+    CUSTOM_CHOICE = "Write my own answer";
+    NONE_CHOICE = "None of the above";
+    MAX_CUSTOM_RESPONSE = 4e3;
   }
 });
 
@@ -18420,6 +18742,12 @@ function deleteSelectedText(value, range) {
   if (!range) return value.slice(0, -1);
   return value.slice(0, range[0]) + value.slice(range[1]);
 }
+function idlePromptControl(data, hasSelection) {
+  if (data === "\x1B") return hasSelection ? "delete-selection" : "ignore";
+  if (data.includes("")) return "clear";
+  if (data.includes("")) return "exit";
+  return null;
+}
 function handleScrollInput(screen, data) {
   let handled = false;
   const mousePattern = /\x1b\[<(\d+);\d+;\d+[Mm]/g;
@@ -18500,19 +18828,24 @@ function readPrompt(screen) {
         screen.setInput(value);
         return;
       }
-      if (data === "\x1B") {
-        if (selection) {
-          value = deleteSelectedText(value, selection);
-          screen.setInput(value);
-        } else finish(null);
+      const control = idlePromptControl(data, Boolean(selection));
+      if (control === "delete-selection") {
+        value = deleteSelectedText(value, selection);
+        screen.setInput(value);
         return;
       }
+      if (control === "clear") {
+        value = "";
+        screen.setInput(value);
+        return;
+      }
+      if (control === "exit") {
+        finish(null);
+        return;
+      }
+      if (control === "ignore") return;
       if (data.startsWith("\x1B")) return;
       for (const char of data) {
-        if (char === "" || char === "") {
-          finish(null);
-          return;
-        }
         if (char === "\r" || char === "\n") {
           finish(value);
           return;
@@ -18550,12 +18883,11 @@ async function cancellable(screen, run2) {
 }
 async function resolveScreenFixPolls(screen, events) {
   if (!events.some((event) => event.type === "tool-end" && Boolean(event.pollId))) return;
-  screen.leave();
-  try {
-    await resolveFixPolls(events);
-  } finally {
-    screen.enter();
-  }
+  screen.setStatus("Decision required");
+  await resolveFixPolls(events, {
+    render: (lines2) => screen.setInlinePanel(lines2),
+    commit: (lines2) => screen.commitInlinePanel(lines2)
+  });
 }
 async function runSynkroSession(harness, cwd, prompt) {
   if (prompt) return runOnce(harness, cwd, prompt);
@@ -19930,7 +20262,7 @@ function pseudonymousHostnameHash(installationId, host) {
 }
 function cliVersion() {
   try {
-    return "1.10.9";
+    return "1.10.11";
   } catch {
     return "0.0.0";
   }
@@ -20700,7 +21032,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.9");
+  console.log("1.10.11");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents