squadrant 0.11.3 → 0.12.1

package/dist/index.js

@@ -34,14 +34,14 @@ function getDefaultConfig() {
       models: {
         command: "opus",
         captain: "opus",
-        crew: "opus",
+        crew: "sonnet",
         exploration: "haiku",
         review: "opus"
       },
       roles: {
         command: { agent: "claude", model: "opus" },
         captain: { agent: "claude", model: "opus" },
-        crew: { agent: "claude", model: "opus" },
+        crew: { agent: "claude", model: "sonnet" },
         exploration: { agent: "claude", model: "haiku" },
         side: { agent: "claude", model: "opus" }
       },
@@ -579,7 +579,7 @@ var init_config_drift = __esm({
       }
     ];
     KNOWN_DEFAULT_HISTORY = [
-      { path: "defaults.roles.crew.model", oldDefaults: ["sonnet"] },
+      { path: "defaults.roles.crew.model", oldDefaults: ["opus"] },
       { path: "defaults.roles.captain.model", oldDefaults: ["sonnet"] }
     ];
     KNOWN_DRIVERS = /* @__PURE__ */ new Set(["claude", "codex", "gemini", "opencode"]);
@@ -1043,10 +1043,10 @@ var init_watchdog = __esm({
   }
 });
 
-// packages/core/dist/daemon.js
+// packages/core/dist/daemon/reduce.js
 var DEFAULT_TASK_TIMEOUT_MS, TERMINAL_RECORD_TTL_MS;
-var init_daemon = __esm({
-  "packages/core/dist/daemon.js"() {
+var init_reduce = __esm({
+  "packages/core/dist/daemon/reduce.js"() {
     init_dist();
     init_state_machine();
     init_watchdog();
@@ -1449,9 +1449,9 @@ var init_captain_delivery = __esm({
   }
 });
 
-// packages/core/dist/daemon/delivery.js
-var init_delivery = __esm({
-  "packages/core/dist/daemon/delivery.js"() {
+// packages/core/dist/daemon/delivery-loop.js
+var init_delivery_loop = __esm({
+  "packages/core/dist/daemon/delivery-loop.js"() {
     init_mailbox();
     init_captain_delivery();
     init_dist();
@@ -1489,9 +1489,9 @@ import { readdir } from "fs/promises";
 var SNAPSHOT_LOG_WINDOW_MS;
 var init_start = __esm({
   "packages/core/dist/daemon/start.js"() {
-    init_daemon();
+    init_reduce();
     init_probes();
-    init_delivery();
+    init_delivery_loop();
     init_gates();
     init_server();
     init_mailbox();
@@ -1683,6 +1683,17 @@ var init_commands = __esm({
   }
 });
 
+// packages/core/dist/telegram/control.js
+import { execFile } from "child_process";
+import { promisify } from "util";
+var pExecFile;
+var init_control2 = __esm({
+  "packages/core/dist/telegram/control.js"() {
+    init_protocol();
+    pExecFile = promisify(execFile);
+  }
+});
+
 // packages/core/dist/telegram/ensure-captain.js
 var init_ensure_captain = __esm({
   "packages/core/dist/telegram/ensure-captain.js"() {
@@ -1799,6 +1810,12 @@ function createTelegramClient(opts) {
     },
     async setMyCommands(commands) {
       await call("setMyCommands", { commands });
+    },
+    async sendChatAction(chatId, threadId, action) {
+      const body = { chat_id: chatId, action };
+      if (threadId !== void 0)
+        body.message_thread_id = threadId;
+      await call("sendChatAction", body);
     }
   };
 }
@@ -1843,6 +1860,46 @@ var init_bridge = __esm({
   }
 });
 
+// packages/core/dist/restart-daemon.js
+import { execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join11 } from "path";
+function defaultIsRunning() {
+  return existsSync8(DEFAULT_SOCK_PATH);
+}
+function defaultRunKickstart() {
+  const uid = process.getuid?.() ?? 0;
+  const target = `gui/${uid}/${LABEL}`;
+  if (tryAcquireDaemonLock()) {
+    try {
+      execFileSync4("launchctl", kickstartArgv(target, true), { stdio: "ignore" });
+    } finally {
+      releaseDaemonLock();
+    }
+  }
+}
+function restartDaemonIfRunning(opts) {
+  const env = opts.env ?? process.env;
+  if (env["VITEST"] || opts.noRestart)
+    return "skipped-opt-out";
+  const isRunning = opts.isRunning ?? defaultIsRunning;
+  if (!isRunning())
+    return "skipped-not-running";
+  const log = opts.log ?? console.log;
+  log(`\u21BB restarting daemon to apply ${opts.reason}\u2026`);
+  const runKickstart = opts.runKickstart ?? defaultRunKickstart;
+  runKickstart();
+  return "restarted";
+}
+var DEFAULT_SOCK_PATH;
+var init_restart_daemon = __esm({
+  "packages/core/dist/restart-daemon.js"() {
+    init_launchd();
+    DEFAULT_SOCK_PATH = join11(homedir6(), ".config", "squadrant", "squadrant.sock");
+  }
+});
+
 // packages/core/dist/telegram/setup.js
 import fs10 from "fs";
 function resolveSetupGroup(existingSupergroupId, opts) {
@@ -1868,6 +1925,26 @@ async function detectGroupAndUser(client, opts = {}) {
   }
   throw new Error("Timed out waiting for the bot to receive a message in a supergroup");
 }
+function resolveSetupToken(existingToken, opts) {
+  if (opts.resetToken || !existingToken)
+    return "prompt";
+  return "try-reuse";
+}
+function resolveSetupUserId(flagUserId, detectedUserId, stateRoot) {
+  return flagUserId ?? detectedUserId ?? loadState(stateRoot).lastUserId;
+}
+async function runRegisterCommands(opts) {
+  await opts.client.setMyCommands(BOT_COMMANDS);
+}
+function runTelegramPostSetup(opts) {
+  const doRestart = opts.doRestart ?? restartDaemonIfRunning;
+  const outcome = doRestart({ reason: "telegram config" });
+  if (outcome === "skipped-not-running") {
+    console.log("(daemon not running \u2014 change applies on next start)");
+  } else if (outcome === "skipped-opt-out") {
+    console.log("(run 'squadrant heal daemon' to apply)");
+  }
+}
 function writeTelegramConfig(configPath, opts) {
   let config;
   let raw = null;
@@ -1904,6 +1981,97 @@ function writeTelegramConfig(configPath, opts) {
 }
 var init_setup = __esm({
   "packages/core/dist/telegram/setup.js"() {
+    init_state();
+    init_bot_commands();
+    init_restart_daemon();
+  }
+});
+
+// packages/core/dist/telegram/notify.js
+function runTelegramStatus(opts) {
+  const tg = opts.config.telegram;
+  const env = opts.env ?? process.env;
+  const tokenSet = !!(tg?.botToken ?? env.TELEGRAM_BOT_TOKEN);
+  const links = Object.entries(loadState(opts.stateRoot).topics).map(([key, topicId]) => {
+    const sep2 = key.indexOf("::");
+    return { project: key.slice(0, sep2), scope: key.slice(sep2 + 2), topicId };
+  });
+  return { tokenSet, supergroupId: tg?.supergroupId ?? null, links };
+}
+function runTelegramNotifySet(opts) {
+  setNotify(opts.stateRoot, opts.project, opts.active);
+}
+function runTelegramNotifyPref(args) {
+  const { project, dimension, value, root } = args;
+  if (dimension === "crew") {
+    if (!["all", "alert_only", "done_only", "none"].includes(value))
+      return { ok: false, message: "crew must be all|alert_only|done_only|none" };
+    saveProjectOverride(project, { telegram: { notify: { crew: value } } }, root);
+    return { ok: true };
+  }
+  if (value !== "on" && value !== "off")
+    return { ok: false, message: "cap must be on|off" };
+  saveProjectOverride(project, { telegram: { notify: { cap: value === "on" } } }, root);
+  return { ok: true };
+}
+function runTelegramNotifyStatus(opts) {
+  const s = loadState(opts.stateRoot);
+  const projects = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(s.topics)) {
+    const sep2 = key.indexOf("::");
+    projects.add(sep2 === -1 ? key : key.slice(0, sep2));
+  }
+  for (const p of Object.keys(s.notify))
+    projects.add(p);
+  return [...projects].map((project) => ({ project, active: s.notify[project] === true }));
+}
+function capAllowed(project, globalNotify, root) {
+  return resolveNotify(globalNotify, loadProjectOverride(project, root)).cap;
+}
+function confirmationText(project, before, after, dim) {
+  if (dim === "active")
+    return `\u{1F515} ${project} \u2014 all notifications muted here. Unmute: squadrant telegram notify ${project} on`;
+  if (dim === "cap")
+    return `\u{1F515} ${project} \u2014 captain messages muted here. Re-enable: squadrant telegram notify ${project} cap on`;
+  return `\u{1F515} ${project} \u2014 crew notifications now '${after.crew}' (was '${before.crew}'). Re-enable: squadrant telegram notify ${project} crew ${before.crew}`;
+}
+async function runNotifyConfirmation(opts) {
+  const { quieter, dim } = isQuieter(opts.before, opts.after);
+  if (!quieter || dim === null)
+    return false;
+  const topicId = loadState(opts.stateRoot).topics[topicKey(opts.project)];
+  if (topicId === void 0)
+    return false;
+  const text = confirmationText(opts.project, opts.before, opts.after, dim);
+  try {
+    await opts.client.sendMessage(opts.cfg.supergroupId, topicId, text);
+    return true;
+  } catch {
+    console.warn(`[squadrant] mute-confirmation send failed for ${opts.project} \u2014 notification preference was still saved`);
+    return false;
+  }
+}
+async function runTelegramSend(opts) {
+  const topicId = loadState(opts.stateRoot).topics[topicKey(opts.project)];
+  if (topicId === void 0) {
+    throw new Error(`project "${opts.project}" is not linked \u2014 run: squadrant telegram link ${opts.project}`);
+  }
+  await opts.client.sendMessage(opts.cfg.supergroupId, topicId, opts.message);
+  return { chatId: opts.cfg.supergroupId, topicId };
+}
+async function runTelegramLink(opts) {
+  const existing = loadState(opts.stateRoot).topics[topicKey(opts.project)];
+  if (existing !== void 0)
+    return { topicId: existing, created: false };
+  const topicId = await opts.client.createForumTopic(opts.cfg.supergroupId, topicName(opts.project));
+  setTopic(opts.stateRoot, opts.project, topicId);
+  return { topicId, created: true };
+}
+var init_notify = __esm({
+  "packages/core/dist/telegram/notify.js"() {
+    init_dist();
+    init_state();
+    init_format();
   }
 });
 
@@ -1913,121 +2081,737 @@ var init_telegram = __esm({
     init_bot_commands();
     init_auth();
     init_commands();
+    init_control2();
     init_ensure_captain();
     init_format();
     init_state();
     init_client();
     init_bridge();
     init_setup();
+    init_notify();
   }
 });
 
-// packages/core/dist/index.js
-var init_dist2 = __esm({
-  "packages/core/dist/index.js"() {
-    init_daemon();
-    init_mailbox();
-    init_protocol();
-    init_state_machine();
-    init_liveness();
-    init_watchdog();
-    init_store();
-    init_snapshot();
-    init_launchd();
-    init_crew_pane_reader();
-    init_interfaces();
-    init_gate();
-    init_context();
-    init_attach();
-    init_start();
-    init_delivery();
-    init_interactive_probe();
-    init_captain_delivery();
-    init_defer_delivery();
-    init_session_freshness();
-    init_crew_protocol();
-    init_crew_lifecycle();
-    init_telegram();
+// packages/core/dist/crew-routing.js
+function resolveCrewRoute(taskText, config) {
+  const rules = config.defaults.crewRouting?.rules;
+  if (!rules || rules.length === 0)
+    return null;
+  for (const rule2 of rules) {
+    const re = new RegExp(rule2.match, "i");
+    if (re.test(taskText)) {
+      return {
+        agent: rule2.agent,
+        ...rule2.model !== void 0 ? { model: rule2.model } : {},
+        tier: rule2.tier,
+        matchedRule: rule2.match
+      };
+    }
+  }
+  return null;
+}
+var init_crew_routing = __esm({
+  "packages/core/dist/crew-routing.js"() {
   }
 });
 
-// packages/workspaces/dist/runtimes/cmux.js
-import { execFile, execFileSync as execFileSync4 } from "child_process";
-function isInsideCmux() {
-  return !!process.env.CMUX_WORKSPACE_ID;
-}
-function cmuxLocal(args) {
-  return execFileSync4(resolveCmuxBin(), args, {
-    encoding: "utf-8",
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: CMUX_TIMEOUT
-  }).trim();
-}
-function cmux(args) {
-  return new Promise((resolve3, reject) => {
-    execFile(
-      resolveCmuxBin(),
-      args,
-      // CMUX_QUIET=1 silences cmux 0.64's one-time deprecation hints (e.g. the
-      // "list-workspaces is now an alias for cmux workspace list" notice). Those
-      // notices print to the command's stdout and would otherwise pollute the
-      // output we parse. Inherit the rest of the environment unchanged.
-      { encoding: "utf-8", timeout: CMUX_TIMEOUT, env: { ...process.env, CMUX_QUIET: "1" } },
-      (err, stdout) => {
-        if (err) {
-          reject(err.code === "ETIMEDOUT" ? new CmuxTimeoutError(args.join(" ")) : err);
-          return;
-        }
-        resolve3(stdout.trim());
-      }
-    );
-  });
+// packages/core/dist/group-dispatch.js
+import { randomUUID as randomUUID3 } from "crypto";
+import { homedir as homedir7 } from "os";
+import { join as join12 } from "path";
+function resolveCurrentProject(config) {
+  const cwd = process.cwd();
+  for (const [name, proj] of Object.entries(config.projects)) {
+    const resolvedPath = resolveHome(proj.path);
+    if (cwd.startsWith(resolvedPath))
+      return name;
+  }
+  return null;
 }
-function parseList(output) {
-  let parsed;
+async function isCaptainAlive(project, sockPath = DEFAULT_SOCK_PATH2) {
   try {
-    parsed = JSON.parse(output);
+    const health = await sendRequest(sockPath, { kind: "health", project }, 5e3);
+    const captain = health?.find((h) => h.kind === "captain" && h.project === project);
+    return captain != null && captain.state !== "gone" && captain.state !== "unknown";
   } catch {
-    return [];
-  }
-  const refs = [];
-  for (const ws of parsed.workspaces ?? []) {
-    if (!ws.ref)
-      continue;
-    refs.push({
-      id: ws.ref,
-      name: ws.has_custom_title && ws.custom_title ? ws.custom_title : ws.current_directory ?? ws.ref,
-      status: "running"
-    });
+    return false;
   }
-  return refs;
 }
-function sanitizeForCmuxSend(text) {
-  return text.replace(/\\[nrt]/g, " ").replace(/[\n\r\t]+/g, " ").replace(/ {2,}/g, " ").trim();
+async function waitForWarmup(project, sockPath = DEFAULT_SOCK_PATH2, timeoutMs = GROUP_DISPATCH_WARMUP_TIMEOUT_MS, pollMs = GROUP_DISPATCH_WARMUP_POLL_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isCaptainAlive(project, sockPath))
+      return true;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return false;
 }
-function parseDraftFromScreen(screen) {
-  if (!screen)
-    return null;
-  const lines = screen.split(/\r?\n/);
-  const HR_RE = /^\s*─{10,}\s*$/;
-  let bottomHR = -1;
-  let topHR = -1;
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (HR_RE.test(lines[i])) {
-      if (bottomHR === -1) {
-        bottomHR = i;
-      } else {
-        topHR = i;
-        break;
-      }
-    }
+async function dispatchToSibling(opts) {
+  const config = loadConfig();
+  const fromCfg = config.projects[opts.fromProject];
+  const toCfg = config.projects[opts.toProject];
+  if (!toCfg) {
+    throw new Error(`target project '${opts.toProject}' not found in config`);
   }
-  if (topHR === -1)
-    return null;
-  const inputLines = lines.slice(topHR + 1, bottomHR);
-  for (const line of inputLines) {
-    let extracted;
-    const boxMatch = line.match(/│\s*[>❯]\s+(.*?)\s*│/);
+  if (!fromCfg.group || !toCfg.group || fromCfg.group !== toCfg.group) {
+    throw new Error(`cannot dispatch: '${opts.toProject}' (group: ${toCfg.group ?? "none"}) is not in the same group as '${opts.fromProject}' (group: ${fromCfg.group ?? "none"})`);
+  }
+  if (toCfg.acceptDelegations === false) {
+    throw new Error(`cannot dispatch to '${opts.toProject}': project has acceptDelegations set to false`);
+  }
+  const sockPath = opts.sockPath ?? DEFAULT_SOCK_PATH2;
+  const alive = await isCaptainAlive(opts.toProject, sockPath);
+  if (!alive) {
+    if (opts.bootCaptain) {
+      await opts.bootCaptain(opts.toProject);
+    }
+    const warmed = await waitForWarmup(opts.toProject, sockPath, opts.warmupTimeoutMs, opts.warmupPollMs);
+    if (!warmed) {
+      throw new Error(`dispatch to '${opts.toProject}' timed out waiting for captain warmup (>${(opts.warmupTimeoutMs ?? GROUP_DISPATCH_WARMUP_TIMEOUT_MS) / 1e3}s)`);
+    }
+  }
+  const now = Date.now();
+  const attemptId = randomUUID3();
+  const record = {
+    id: randomUUID3(),
+    project: opts.toProject,
+    originProject: opts.fromProject,
+    provider: opts.provider ?? "claude",
+    mode: opts.mode ?? "headless",
+    state: "submitted",
+    task: opts.task,
+    createdAt: now,
+    lastHeartbeat: now,
+    lastEvent: "dispatch",
+    heartbeatBudgetMs: 3e5,
+    attempts: [{ attemptId, startedAt: now, lastHeartbeatAt: now }]
+  };
+  const result = await sendRequest(sockPath, { kind: "dispatch", record });
+  return result;
+}
+var DEFAULT_SOCK_PATH2, GROUP_DISPATCH_WARMUP_TIMEOUT_MS, GROUP_DISPATCH_WARMUP_POLL_MS;
+var init_group_dispatch = __esm({
+  "packages/core/dist/group-dispatch.js"() {
+    init_dist();
+    init_protocol();
+    DEFAULT_SOCK_PATH2 = join12(homedir7(), ".config", "squadrant", "squadrant.sock");
+    GROUP_DISPATCH_WARMUP_TIMEOUT_MS = 12e4;
+    GROUP_DISPATCH_WARMUP_POLL_MS = 1e3;
+  }
+});
+
+// packages/core/dist/launch-workspace.js
+async function deliverStartupPrompt(runtime, refId, prompt, opts = {}) {
+  const classify = opts.classifyScreen ?? (() => "idle");
+  const readyTimeoutMs = opts.readyTimeoutMs ?? 3e4;
+  const settleMs = opts.settleMs ?? 2500;
+  const pollMs = opts.pollMs ?? 1e3;
+  const maxAttempts = opts.maxAttempts ?? 3;
+  const sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+  const read = async () => runtime.readScreen(refId).catch(() => "");
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const deadline = Date.now() + readyTimeoutMs;
+    let preSend = await read();
+    let state = classify(preSend);
+    while (state === "loading" && Date.now() < deadline) {
+      await sleep2(pollMs);
+      preSend = await read();
+      state = classify(preSend);
+    }
+    if (state === "working")
+      return;
+    await runtime.send(refId, prompt).catch(() => {
+    });
+    if (state === "loading")
+      return;
+    await sleep2(settleMs);
+    const after = await read();
+    if (after !== preSend)
+      return;
+  }
+}
+async function bootWorkspace(opts) {
+  const { runtime, workspaceName, agentCmd, cwd, navigate = false, forceFresh = false, pinToTop = false, initialPrompt } = opts;
+  const existing = await runtime.status(workspaceName);
+  if (existing && forceFresh) {
+    opts.onStoppingStale?.(workspaceName);
+    await runtime.stop(existing.id);
+  } else if (existing) {
+    opts.onAlreadyExists?.(workspaceName);
+    opts.selectWorkspace?.(existing.id);
+    return;
+  }
+  const rawCurrent = opts.getCurrentWorkspace?.() ?? null;
+  const currentRef = rawCurrent?.match(/workspace:\d+/)?.[0];
+  const ref = await runtime.spawn({
+    name: workspaceName,
+    workdir: cwd ?? process.cwd(),
+    command: agentCmd,
+    pinToTop
+  });
+  if (initialPrompt) {
+    void deliverStartupPrompt(runtime, ref.id, initialPrompt, {
+      classifyScreen: opts.classifyScreen
+    });
+  }
+  if (navigate) {
+    opts.selectWorkspace?.(ref.id);
+  } else if (currentRef) {
+    opts.selectWorkspace?.(currentRef);
+  }
+  opts.onCreated?.(workspaceName);
+}
+async function launchOneWorkspace(opts) {
+  let forceFresh = !!opts.forceFreshOverride;
+  if (!forceFresh) {
+    const auto = shouldStartFresh(opts.workspaceName, opts.role, {
+      sessionsPath: opts.sessionsPath,
+      templatesDir: opts.templatesDir
+    });
+    if (auto.fresh) {
+      opts.onFreshReason?.(auto.reason ?? "starting fresh");
+      forceFresh = true;
+    }
+  }
+  const agentCmd = opts.agentCmdFactory(forceFresh);
+  recordSession(opts.workspaceName, opts.role, {
+    sessionsPath: opts.sessionsPath,
+    templatesDir: opts.templatesDir
+  });
+  await bootWorkspace({
+    runtime: opts.runtime,
+    workspaceName: opts.workspaceName,
+    agentCmd,
+    cwd: opts.cwd,
+    navigate: opts.navigate,
+    forceFresh,
+    pinToTop: opts.pinToTop,
+    initialPrompt: opts.initialPrompt,
+    classifyScreen: opts.classifyScreen,
+    selectWorkspace: opts.selectWorkspace,
+    getCurrentWorkspace: opts.getCurrentWorkspace,
+    onStoppingStale: opts.onStoppingStale,
+    onAlreadyExists: opts.onAlreadyExists,
+    onCreated: opts.onCreated
+  });
+}
+var init_launch_workspace = __esm({
+  "packages/core/dist/launch-workspace.js"() {
+    init_session_freshness();
+  }
+});
+
+// packages/core/dist/side-session.js
+import fs11 from "fs";
+function sideTitleFor(project, name) {
+  return `\u{1F5D2} ${project}:${name}`;
+}
+function isSideTitle(project, title) {
+  return title.startsWith(`\u{1F5D2} ${project}:`);
+}
+function sideNameFromTitle(project, title) {
+  return title.slice(`\u{1F5D2} ${project}:`.length);
+}
+function sideNextAutoName(existingTitles, project) {
+  const used = /* @__PURE__ */ new Set();
+  for (const title of existingTitles) {
+    const n = sideNameFromTitle(project, title).match(/^side-(\d+)$/);
+    if (n)
+      used.add(Number(n[1]));
+  }
+  let i = 1;
+  while (used.has(i))
+    i++;
+  return `side-${i}`;
+}
+function buildSideFirstTurn(topic, project, role, spokeVault, scratchWorktree) {
+  const lines = [
+    topic,
+    "",
+    "---",
+    "Side-session context (for handoff use):",
+    `Project: ${project}`,
+    `Role: ${role}`,
+    `Spoke vault: ${spokeVault}`
+  ];
+  if (scratchWorktree) {
+    lines.push(`Scratch worktree: ${scratchWorktree}`);
+  }
+  return lines.join("\n");
+}
+async function runSideSpawn(input, config, deps) {
+  const proj = config.projects[input.project];
+  if (!proj) {
+    throw new Error(`Project '${input.project}' not found. Run 'squadrant projects list'.`);
+  }
+  if (!SIDE_ROLES.includes(input.role)) {
+    throw new Error(`Unknown side role '${input.role}'. Valid roles: ${SIDE_ROLES.join(", ")}.`);
+  }
+  const { runtime } = deps;
+  const captain = await runtime.status(proj.captainName);
+  if (!captain) {
+    throw new Error(`Captain workspace '${proj.captainName}' is not running. Run 'squadrant launch ${input.project}' first.`);
+  }
+  const existing = await runtime.listSurfaces(captain.id);
+  const existingTitles = existing.filter((s) => s.title && isSideTitle(input.project, s.title)).map((s) => s.title);
+  if (input.name) {
+    const wantTitle = sideTitleFor(input.project, input.name);
+    if (existingTitles.includes(wantTitle)) {
+      throw new Error(`Side session '${input.name}' already exists for ${input.project}.`);
+    }
+  }
+  const name = input.name ?? sideNextAutoName(existingTitles, input.project);
+  const spawnCwd = input.role === "debug" ? addWorktree({
+    repoRoot: proj.path,
+    worktreeDir: config.defaults.worktreeDir ?? ".worktrees",
+    project: input.project,
+    name,
+    base: resolveWorktreeBase(proj.path)
+  }) : proj.path;
+  const agentCmd = deps.agentCmdFactory(spawnCwd);
+  const direction = input.direction ?? "tab";
+  const title = sideTitleFor(input.project, name);
+  const pane = await runtime.newPane({ workspaceId: captain.id, direction, title });
+  await runtime.sendToPane(pane, `cd ${shellQuote(spawnCwd)} && ${agentCmd}`);
+  const preLaunchScreen = await runtime.readPaneScreen(pane) ?? "";
+  const firstTurn = buildSideFirstTurn(input.topic, input.project, input.role, proj.spokeVault ?? "", input.role === "debug" ? spawnCwd : void 0);
+  await deps.sendFirstTurn(pane, firstTurn, preLaunchScreen);
+  return { ...pane, title };
+}
+async function runSideSend(runtime, workspaceId, project, name, message) {
+  const want = sideTitleFor(project, name);
+  const surfaces = await runtime.listSurfaces(workspaceId);
+  const pane = surfaces.find((s) => s.title === want) ?? null;
+  if (!pane) {
+    throw new Error(`Side session '${name}' not found for ${project}. Run 'squadrant side list ${project}'.`);
+  }
+  await runtime.sendToPane(pane, message);
+}
+async function runSideList(runtime, workspaceId, project) {
+  const surfaces = await runtime.listSurfaces(workspaceId);
+  return surfaces.filter((s) => s.title && isSideTitle(project, s.title)).map((s) => ({
+    name: sideNameFromTitle(project, s.title),
+    surfaceId: s.surfaceId
+  }));
+}
+async function runSideClose(runtime, workspaceId, project, name, projPath, worktreeDir) {
+  const want = sideTitleFor(project, name);
+  const surfaces = await runtime.listSurfaces(workspaceId);
+  const pane = surfaces.find((s) => s.title === want) ?? null;
+  if (!pane) {
+    throw new Error(`Side session '${name}' not found for ${project}. Run 'squadrant side list ${project}'.`);
+  }
+  await runtime.closePane(pane);
+  if (projPath) {
+    const wtPath = worktreePath(projPath, worktreeDir, project, name);
+    if (fs11.existsSync(wtPath)) {
+      try {
+        removeWorktree(projPath, wtPath);
+      } catch (e) {
+        process.stderr.write(`(worktree remove failed: ${e.message})
+`);
+      }
+    }
+  }
+}
+var SIDE_ROLES;
+var init_side_session = __esm({
+  "packages/core/dist/side-session.js"() {
+    init_dist();
+    init_crew_protocol();
+    SIDE_ROLES = ["research", "debug"];
+  }
+});
+
+// packages/core/dist/crew-spawn.js
+import fs12 from "fs";
+import os4 from "os";
+import path10 from "path";
+async function listCrewPanes(runtime, workspaceId, project) {
+  const surfaces = await runtime.listSurfaces(workspaceId);
+  return surfaces.filter((s) => s.title && isCrewTitle(project, s.title));
+}
+async function findCrewPane(runtime, workspaceId, project, name) {
+  const want = titleFor(project, name);
+  const surfaces = await runtime.listSurfaces(workspaceId);
+  return surfaces.find((s) => s.title === want) ?? null;
+}
+async function runCodexInteractiveSpawn(o) {
+  const rec = await o.dispatchCrew({
+    provider: "codex",
+    mode: "interactive",
+    project: o.project,
+    cwd: o.cwd,
+    task: o.task,
+    name: o.name,
+    ...o.approvalPolicy ? { approvalPolicy: o.approvalPolicy } : {},
+    ...o.roleInstructions ? { roleInstructions: o.roleInstructions } : {}
+  });
+  const title = titleFor(o.project, o.name);
+  const pane = await o.runtime.newPane({
+    workspaceId: o.workspaceId,
+    direction: o.direction,
+    title
+  });
+  await o.runtime.sendToPane(pane, `squadrant crew attach ${rec.id}`);
+  if (o.task && o.task !== "(interactive)") {
+    void o.sendCodexFirstTurn(rec.id, o.task).catch((e) => {
+      process.stderr.write(`(first-turn delivery failed: ${e.message})
+`);
+    });
+  }
+  return { ...pane, title };
+}
+async function runCrewSpawn(input, config, deps) {
+  const proj = config.projects[input.project];
+  if (!proj) {
+    throw new Error(`Project '${input.project}' not found. Run 'squadrant projects list'.`);
+  }
+  const captain = await deps.runtime.status(proj.captainName);
+  if (!captain) {
+    throw new Error(`Captain workspace '${proj.captainName}' is not running. Run 'squadrant launch ${input.project}' first.`);
+  }
+  const existing = await listCrewPanes(deps.runtime, captain.id, input.project);
+  const existingTitles = existing.map((s) => s.title);
+  if (input.name) {
+    const wantTitle = titleFor(input.project, input.name);
+    if (existingTitles.includes(wantTitle)) {
+      throw new Error(`Crew '${input.name}' already exists for ${input.project}. Use 'squadrant crew send ${input.project} ${input.name}' to send a follow-up, or pick a different --name.`);
+    }
+  }
+  const name = input.name ?? nextAutoName(existingTitles, input.project);
+  const spawnCwd = !input.shared ? addWorktree({
+    repoRoot: proj.path,
+    worktreeDir: config.defaults.worktreeDir ?? ".worktrees",
+    project: input.project,
+    name,
+    base: resolveWorktreeBase(proj.path)
+  }) : proj.path;
+  const route = !input.agentExplicit && !input.model ? resolveCrewRoute(input.task, config) : null;
+  if (route) {
+    deps.onRouted?.(route);
+  }
+  const agentName = route?.agent ?? input.agent ?? "claude";
+  const agent = deps.resolveAgent(agentName);
+  if (!agent) {
+    throw new Error(`Unknown agent '${agentName}'. Known: claude, codex, gemini, opencode.`);
+  }
+  if (agentName === "codex") {
+    const codexRoleFile = path10.join(TEMPLATES_DIR, `crew.${agent.templateSuffix}.md`);
+    const roleInstructions = fs12.existsSync(codexRoleFile) ? fs12.readFileSync(codexRoleFile, "utf8") : void 0;
+    return runCodexInteractiveSpawn({
+      project: input.project,
+      task: input.task,
+      cwd: spawnCwd,
+      runtime: deps.runtime,
+      workspaceId: captain.id,
+      name,
+      direction: input.direction ?? "tab",
+      approvalPolicy: input.approvalPolicy,
+      roleInstructions,
+      dispatchCrew: deps.dispatchCrew,
+      sendCodexFirstTurn: deps.sendCodexFirstTurn
+    });
+  }
+  const promptFile = path10.join(TEMPLATES_DIR, `crew.${agent.templateSuffix}.md`);
+  const interactive = agent.name === "claude" || agent.name === "opencode";
+  const crewRole = config.defaults.roles?.crew;
+  const configModel = crewRole && crewRole.agent === agent.name ? crewRole.model : void 0;
+  const crewModel = input.model ?? route?.model ?? configModel;
+  if (agentName === "claude") {
+    const rec = await deps.dispatchCrew({
+      provider: "claude",
+      mode: "interactive",
+      project: input.project,
+      cwd: spawnCwd,
+      task: input.task,
+      name
+    });
+    deps.writeSettingsLocal(spawnCwd);
+    const cliCommand2 = agent.buildCommand({
+      prompt: input.task,
+      workdir: spawnCwd,
+      role: "crew",
+      promptFile,
+      interactive: true,
+      // Permission mode is config-driven so squadrant can default crews to 'auto'
+      // or keep the semi-automatic 'acceptEdits' gate. Falls back to 'acceptEdits'.
+      permissionMode: config.defaults.permissions?.crew ?? "acceptEdits",
+      ...crewModel ? { model: crewModel } : {}
+    });
+    const direction2 = input.direction ?? "tab";
+    const title2 = titleFor(input.project, name);
+    const pane2 = await deps.runtime.newPane({ workspaceId: captain.id, direction: direction2, title: title2 });
+    const envPrefix = `SQUADRANT_CREW_TASK_ID=${rec.id} SQUADRANT_CREW_PROJECT=${input.project}`;
+    await deps.runtime.sendToPane(pane2, `cd ${shellQuote(spawnCwd)} && ${envPrefix} ${cliCommand2}`);
+    const preLaunchScreen = await deps.runtime.readPaneScreen(pane2) ?? "";
+    await deps.sendFirstTurn(pane2, `${input.task}
+
+${buildCompletionProtocol(rec.id, input.project)}`, preLaunchScreen);
+    return { ...pane2, title: title2 };
+  }
+  if (agentName === "opencode") {
+    const serverPort = await deps.getFreePort();
+    const rec = await deps.dispatchCrew({
+      provider: "opencode",
+      mode: "interactive",
+      project: input.project,
+      cwd: spawnCwd,
+      task: input.task,
+      name,
+      // opencode has no heartbeat hook, so a normal budget would false-stall
+      // every crew after 5min; use a 24h budget to effectively disable stall
+      // detection. The SSE bridge (serverPort) provides turn-end liveness.
+      budgetMs: 864e5,
+      serverPort
+    });
+    const opencodeConfigPath = deps.writeOpencodeConfig({
+      stateRoot: STATE_ROOT,
+      project: input.project,
+      taskId: rec.id,
+      // CP3 opt-in: --approval gates bash so the captain approves shell commands.
+      ...input.approval ? { gateBash: true } : {}
+    });
+    const cliCommand2 = agent.buildCommand({
+      prompt: input.task,
+      workdir: spawnCwd,
+      role: "crew",
+      promptFile,
+      interactive: true,
+      model: crewModel,
+      port: serverPort
+    });
+    const direction2 = input.direction ?? "tab";
+    const title2 = titleFor(input.project, name);
+    const pane2 = await deps.runtime.newPane({ workspaceId: captain.id, direction: direction2, title: title2 });
+    const envPrefix = `SQUADRANT_CREW_TASK_ID=${rec.id} SQUADRANT_CREW_PROJECT=${input.project}`;
+    await deps.runtime.sendToPane(pane2, `cd ${shellQuote(spawnCwd)} && ${envPrefix} OPENCODE_CONFIG=${opencodeConfigPath} ${cliCommand2}`);
+    const preLaunchScreen = await deps.runtime.readPaneScreen(pane2) ?? "";
+    await deps.sendFirstTurn(pane2, `${input.task}
+
+${buildCompletionProtocol(rec.id, input.project)}`, preLaunchScreen, {
+      // #235: confirm-on-delivery — sendFirstTurnWhenReady polls until "Ask
+      // anything…" leaves the screen, re-sending every ~3s to cover slow boots
+      // without duplicating the task. See crew-pane.ts SPLASH_MAX_CHECKS/EVERY_N.
+      splashMarker: "Ask anything\u2026"
+    });
+    return { ...pane2, title: title2 };
+  }
+  const cliCommand = agent.buildCommand({
+    prompt: input.task,
+    workdir: spawnCwd,
+    role: "crew",
+    promptFile,
+    interactive,
+    model: crewModel
+  });
+  const direction = input.direction ?? "tab";
+  const title = titleFor(input.project, name);
+  const pane = await deps.runtime.newPane({ workspaceId: captain.id, direction, title });
+  await deps.runtime.sendToPane(pane, cliCommand);
+  if (interactive) {
+    const preLaunchScreen = await deps.runtime.readPaneScreen(pane) ?? "";
+    await deps.sendFirstTurn(pane, input.task, preLaunchScreen);
+  }
+  return { ...pane, title };
+}
+async function runCrewSend(project, name, message, runtime, workspaceId, deps) {
+  const crew = await findCrewPane(runtime, workspaceId, project, name);
+  if (!crew) {
+    throw new Error(`Crew '${name}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
+  }
+  try {
+    const tasks = await deps.listTasks(project);
+    const task = tasks.find((t) => t.name === name);
+    if (task) {
+      if (TERMINAL_STATES.has(task.state)) {
+        await deps.emitEvent(project, { type: "task.reopened", id: task.id });
+      } else if (task.state === "blocked" || task.state === "awaiting-input") {
+        await deps.emitEvent(project, { type: "task.started", id: task.id });
+      }
+    }
+  } catch {
+  }
+  const deliver = deps.sendToPane ?? ((pane, msg) => runtime.sendToPane(pane, msg));
+  await deliver(crew, message);
+}
+async function runCrewRead(project, name, runtime, workspaceId) {
+  const crew = await findCrewPane(runtime, workspaceId, project, name);
+  if (!crew) {
+    throw new Error(`Crew '${name}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
+  }
+  return runtime.readPaneScreen(crew);
+}
+async function runCrewClose(project, name, runtime, workspaceId, deps) {
+  const projRoot = loadConfig().projects[project]?.path;
+  let taskId;
+  let worktreeCwd;
+  try {
+    const tasks = await deps.listTasks(project);
+    const task = tasks.find((t) => t.name === name);
+    if (task) {
+      taskId = task.id;
+      if (task.cwd && projRoot && task.cwd !== projRoot) {
+        worktreeCwd = task.cwd;
+      }
+      if (!TERMINAL_STATES.has(task.state)) {
+        await deps.emitEvent(project, { type: "task.cancelled", id: task.id, reason: "closed by captain" });
+      }
+      if (task.provider === "codex") {
+        await deps.closeCodexThread(task.id);
+      }
+    }
+  } catch {
+  }
+  const crew = await findCrewPane(runtime, workspaceId, project, name);
+  if (crew) {
+    await runtime.closePane(crew);
+  } else if (taskId === void 0) {
+    throw new Error(`Crew '${name}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
+  }
+  if (taskId !== void 0) {
+    await reapCrewChildren(taskId);
+  }
+  if (worktreeCwd && projRoot) {
+    try {
+      removeWorktree(projRoot, worktreeCwd);
+    } catch (e) {
+      process.stderr.write(`(worktree remove failed: ${e.message})
+`);
+    }
+  }
+}
+async function runCrewList(project, runtime, workspaceId) {
+  const crews = await listCrewPanes(runtime, workspaceId, project);
+  return crews.map((c) => ({
+    name: nameFromTitle(project, c.title),
+    surfaceId: c.surfaceId
+  }));
+}
+var TEMPLATES_DIR, STATE_ROOT;
+var init_crew_spawn = __esm({
+  "packages/core/dist/crew-spawn.js"() {
+    init_dist();
+    init_crew_routing();
+    init_crew_protocol();
+    init_crew_lifecycle();
+    TEMPLATES_DIR = path10.join(os4.homedir(), ".config", "squadrant", "templates");
+    STATE_ROOT = path10.join(os4.homedir(), ".config", "squadrant", "state");
+  }
+});
+
+// packages/core/dist/index.js
+var init_dist2 = __esm({
+  "packages/core/dist/index.js"() {
+    init_reduce();
+    init_mailbox();
+    init_protocol();
+    init_state_machine();
+    init_liveness();
+    init_watchdog();
+    init_store();
+    init_snapshot();
+    init_launchd();
+    init_crew_pane_reader();
+    init_interfaces();
+    init_gate();
+    init_context();
+    init_attach();
+    init_start();
+    init_delivery_loop();
+    init_interactive_probe();
+    init_captain_delivery();
+    init_defer_delivery();
+    init_session_freshness();
+    init_crew_protocol();
+    init_crew_lifecycle();
+    init_telegram();
+    init_crew_routing();
+    init_restart_daemon();
+    init_group_dispatch();
+    init_launch_workspace();
+    init_side_session();
+    init_crew_spawn();
+  }
+});
+
+// packages/workspaces/dist/runtimes/cmux.js
+import { execFile as execFile2, execFileSync as execFileSync5 } from "child_process";
+function isInsideCmux() {
+  return !!process.env.CMUX_WORKSPACE_ID;
+}
+function cmuxLocal(args) {
+  return execFileSync5(resolveCmuxBin(), args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: CMUX_TIMEOUT
+  }).trim();
+}
+function cmux(args) {
+  return new Promise((resolve3, reject) => {
+    execFile2(
+      resolveCmuxBin(),
+      args,
+      // CMUX_QUIET=1 silences cmux 0.64's one-time deprecation hints (e.g. the
+      // "list-workspaces is now an alias for cmux workspace list" notice). Those
+      // notices print to the command's stdout and would otherwise pollute the
+      // output we parse. Inherit the rest of the environment unchanged.
+      { encoding: "utf-8", timeout: CMUX_TIMEOUT, env: { ...process.env, CMUX_QUIET: "1" } },
+      (err, stdout) => {
+        if (err) {
+          reject(err.code === "ETIMEDOUT" ? new CmuxTimeoutError(args.join(" ")) : err);
+          return;
+        }
+        resolve3(stdout.trim());
+      }
+    );
+  });
+}
+function parseList(output) {
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    return [];
+  }
+  const refs = [];
+  for (const ws of parsed.workspaces ?? []) {
+    if (!ws.ref)
+      continue;
+    refs.push({
+      id: ws.ref,
+      name: ws.has_custom_title && ws.custom_title ? ws.custom_title : ws.current_directory ?? ws.ref,
+      status: "running"
+    });
+  }
+  return refs;
+}
+function sanitizeForCmuxSend(text) {
+  return text.replace(/\\[nrt]/g, " ").replace(/[\n\r\t]+/g, " ").replace(/ {2,}/g, " ").trim();
+}
+function parseDraftFromScreen(screen) {
+  if (!screen)
+    return null;
+  const lines = screen.split(/\r?\n/);
+  const HR_RE = /^\s*─{10,}\s*$/;
+  let bottomHR = -1;
+  let topHR = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (HR_RE.test(lines[i])) {
+      if (bottomHR === -1) {
+        bottomHR = i;
+      } else {
+        topHR = i;
+        break;
+      }
+    }
+  }
+  if (topHR === -1)
+    return null;
+  const inputLines = lines.slice(topHR + 1, bottomHR);
+  for (const line of inputLines) {
+    let extracted;
+    const boxMatch = line.match(/│\s*[>❯]\s+(.*?)\s*│/);
     if (boxMatch) {
       extracted = boxMatch[1].trim();
     } else {
@@ -2216,8 +3000,14 @@ function createCmuxDriver() {
       }
     },
     async sendToPane(pane, message) {
-      await cmux(["send", "--workspace", pane.workspaceId, "--surface", pane.surfaceId, sanitizeForCmuxSend(message)]);
-      await cmux(["send-key", "--workspace", pane.workspaceId, "--surface", pane.surfaceId, "Enter"]);
+      await this.pasteToPane(pane, message);
+      await this.sendKeyToPane(pane, "Enter");
+    },
+    async pasteToPane(pane, text) {
+      await cmux(["send", "--workspace", pane.workspaceId, "--surface", pane.surfaceId, sanitizeForCmuxSend(text)]);
+    },
+    async sendKeyToPane(pane, key) {
+      await cmux(["send-key", "--workspace", pane.workspaceId, "--surface", pane.surfaceId, key]);
     },
     async readPaneScreen(pane) {
       try {
@@ -2394,7 +3184,7 @@ var init_runtimes = __esm({
 });
 
 // packages/workspaces/dist/notifiers/cmux.js
-import { execFileSync as execFileSync5, execSync as execSync2 } from "child_process";
+import { execFileSync as execFileSync6, execSync as execSync2 } from "child_process";
 function createCmuxNotifier(_scope) {
   return {
     name: "cmux",
@@ -2411,7 +3201,7 @@ function createCmuxNotifier(_scope) {
       }
     },
     async notify(message) {
-      execFileSync5("squadrant", ["runtime", "send", "--command", message], { encoding: "utf-8", timeout: CMUX_TIMEOUT });
+      execFileSync6("squadrant", ["runtime", "send", "--command", message], { encoding: "utf-8", timeout: CMUX_TIMEOUT });
     }
   };
 }
@@ -2466,13 +3256,13 @@ var init_notifiers = __esm({
 });
 
 // packages/workspaces/dist/workspaces/obsidian.js
-import fs11 from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import path10 from "path";
+import fs13 from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import path11 from "path";
 function resolveInRoot(root, relative) {
-  const joined = path10.resolve(root, relative);
-  const normalized = path10.resolve(root) + path10.sep;
-  if (joined !== path10.resolve(root) && !joined.startsWith(normalized)) {
+  const joined = path11.resolve(root, relative);
+  const normalized = path11.resolve(root) + path11.sep;
+  if (joined !== path11.resolve(root) && !joined.startsWith(normalized)) {
     throw new Error(`Path '${relative}' escapes workspace root`);
   }
   return joined;
@@ -2487,20 +3277,20 @@ function createObsidianDriver(scope) {
     async probe() {
       return {
         installed: true,
-        rootExists: existsSync8(root)
+        rootExists: existsSync9(root)
       };
     },
     async read(rel) {
-      return fs11.readFile(resolveInRoot(root, rel), "utf-8");
+      return fs13.readFile(resolveInRoot(root, rel), "utf-8");
     },
     async write(rel, content) {
       const abs = resolveInRoot(root, rel);
-      await fs11.mkdir(path10.dirname(abs), { recursive: true });
-      await fs11.writeFile(abs, content);
+      await fs13.mkdir(path11.dirname(abs), { recursive: true });
+      await fs13.writeFile(abs, content);
     },
     async exists(rel) {
       try {
-        await fs11.access(resolveInRoot(root, rel));
+        await fs13.access(resolveInRoot(root, rel));
         return true;
       } catch {
         return false;
@@ -2508,13 +3298,13 @@ function createObsidianDriver(scope) {
     },
     async list(rel) {
       try {
-        return await fs11.readdir(resolveInRoot(root, rel));
+        return await fs13.readdir(resolveInRoot(root, rel));
       } catch {
         return [];
       }
     },
     async mkdir(rel) {
-      await fs11.mkdir(resolveInRoot(root, rel), { recursive: true });
+      await fs13.mkdir(resolveInRoot(root, rel), { recursive: true });
     }
   };
 }
@@ -2572,7 +3362,7 @@ var init_workspaces2 = __esm({
   }
 });
 
-// packages/workspaces/dist/cmux/events-bridge.js
+// packages/workspaces/dist/cmux-daemon/events-bridge.js
 import { spawn as nodeSpawn } from "child_process";
 function deriveRunState(eventName) {
   switch (eventName) {
@@ -2587,7 +3377,7 @@ function deriveRunState(eventName) {
 }
 var CmuxEventsBridge;
 var init_events_bridge = __esm({
-  "packages/workspaces/dist/cmux/events-bridge.js"() {
+  "packages/workspaces/dist/cmux-daemon/events-bridge.js"() {
     init_dist();
     CmuxEventsBridge = class {
       child = null;
@@ -2712,11 +3502,11 @@ var init_events_bridge = __esm({
   }
 });
 
-// packages/workspaces/dist/cmux/daemon-cmux.js
+// packages/workspaces/dist/cmux-daemon/daemon-cmux.js
 var DaemonCmux;
 var init_daemon_cmux = __esm({
-  "packages/workspaces/dist/cmux/daemon-cmux.js"() {
-    init_cmux();
+  "packages/workspaces/dist/cmux-daemon/daemon-cmux.js"() {
+    init_dist2();
     DaemonCmux = class {
       driver;
       constructor(driver) {
@@ -2773,6 +3563,16 @@ var init_daemon_cmux = __esm({
 
 // packages/workspaces/dist/crew-pane.js
 import net from "net";
+async function settleInputBox(runtime, pane) {
+  let prev = await runtime.readPaneScreen(pane) ?? "";
+  for (let i = 0; i < SETTLE_MAX_POLLS; i++) {
+    await new Promise((r) => setTimeout(r, SETTLE_POLL_MS));
+    const cur = await runtime.readPaneScreen(pane) ?? "";
+    if (cur === prev)
+      return;
+    prev = cur;
+  }
+}
 function getFreePort() {
   return new Promise((resolve3, reject) => {
     const srv = net.createServer();
@@ -2806,6 +3606,23 @@ async function resolveCaptainWorkspace(project) {
   }
   return { runtime, workspaceId: captain.id };
 }
+async function confirmedSendToPane(runtime, pane, message) {
+  const preSendScreen = await runtime.readPaneScreen(pane) ?? "";
+  await runtime.pasteToPane(pane, message);
+  await settleInputBox(runtime, pane);
+  await runtime.sendKeyToPane(pane, "Enter");
+  for (let attempt = 0; attempt < SUBMIT_RETRY_LIMIT; attempt++) {
+    await new Promise((r) => setTimeout(r, POST_SEND_CHECK_MS));
+    const afterScreen = await runtime.readPaneScreen(pane) ?? "";
+    const draft = parseDraftFromScreen(afterScreen);
+    if (draft === "")
+      return;
+    if (draft === null && afterScreen !== preSendScreen)
+      return;
+    await settleInputBox(runtime, pane);
+    await runtime.sendKeyToPane(pane, "Enter");
+  }
+}
 async function sendFirstTurnWhenReady(runtime, pane, task, preLaunchScreen, acceptanceConfig) {
   await new Promise((r) => setTimeout(r, SEND_FIRST_TURN_FLOOR_MS));
   const maxPolls = Math.floor((SEND_FIRST_TURN_TIMEOUT_MS - SEND_FIRST_TURN_FLOOR_MS) / POLL_INTERVAL_MS);
@@ -2821,20 +3638,37 @@ async function sendFirstTurnWhenReady(runtime, pane, task, preLaunchScreen, acce
     }
   }
   const preSendScreen = await runtime.readPaneScreen(pane) ?? "";
-  await runtime.sendToPane(pane, task);
-  const retryLimit = acceptanceConfig?.retryLimit ?? 2;
+  if (acceptanceConfig?.splashMarker) {
+    await runtime.sendToPane(pane, task);
+    for (let check2 = 0; check2 < SPLASH_MAX_CHECKS; check2++) {
+      await new Promise((r) => setTimeout(r, POST_SEND_CHECK_MS));
+      const afterScreen = await runtime.readPaneScreen(pane) ?? "";
+      if (isTurnAccepted(preSendScreen, afterScreen, acceptanceConfig)) {
+        return;
+      }
+      if ((check2 + 1) % SPLASH_RESEND_EVERY_N === 0 && check2 < SPLASH_MAX_CHECKS - 1) {
+        await runtime.sendToPane(pane, task);
+      }
+    }
+    return;
+  }
+  await runtime.pasteToPane(pane, task);
+  await settleInputBox(runtime, pane);
+  await runtime.sendKeyToPane(pane, "Enter");
+  const retryLimit = acceptanceConfig?.retryLimit ?? SUBMIT_RETRY_LIMIT;
   for (let attempt = 0; attempt < retryLimit; attempt++) {
     await new Promise((r) => setTimeout(r, POST_SEND_CHECK_MS));
     const afterScreen = await runtime.readPaneScreen(pane) ?? "";
-    if (isTurnAccepted(preSendScreen, afterScreen, acceptanceConfig)) {
+    const draft = parseDraftFromScreen(afterScreen);
+    if (draft === "")
       return;
-    }
-    if (attempt < retryLimit - 1) {
-      await runtime.sendToPane(pane, task);
-    }
+    if (draft === null && afterScreen !== preSendScreen)
+      return;
+    await settleInputBox(runtime, pane);
+    await runtime.sendKeyToPane(pane, "Enter");
   }
 }
-var SEND_FIRST_TURN_FLOOR_MS, POLL_INTERVAL_MS, SEND_FIRST_TURN_TIMEOUT_MS, POST_SEND_CHECK_MS;
+var SEND_FIRST_TURN_FLOOR_MS, POLL_INTERVAL_MS, SEND_FIRST_TURN_TIMEOUT_MS, POST_SEND_CHECK_MS, SPLASH_MAX_CHECKS, SPLASH_RESEND_EVERY_N, SETTLE_POLL_MS, SETTLE_MAX_POLLS, SUBMIT_RETRY_LIMIT;
 var init_crew_pane = __esm({
   "packages/workspaces/dist/crew-pane.js"() {
     init_dist();
@@ -2845,6 +3679,11 @@ var init_crew_pane = __esm({
     POLL_INTERVAL_MS = 750;
     SEND_FIRST_TURN_TIMEOUT_MS = 2e4;
     POST_SEND_CHECK_MS = 750;
+    SPLASH_MAX_CHECKS = 20;
+    SPLASH_RESEND_EVERY_N = 4;
+    SETTLE_POLL_MS = 400;
+    SETTLE_MAX_POLLS = 8;
+    SUBMIT_RETRY_LIMIT = 4;
   }
 });
 
@@ -2854,12 +3693,12 @@ __export(dist_exports, {
   CMUX_TIMEOUT: () => CMUX_TIMEOUT,
   CmuxEventsBridge: () => CmuxEventsBridge,
   DaemonCmux: () => DaemonCmux,
-  DeferDelivery: () => DeferDelivery,
   NotifierRegistry: () => NotifierRegistry,
   RuntimeRegistry: () => RuntimeRegistry,
   WorkspaceRegistry: () => WorkspaceRegistry,
   classifyStartupSurface: () => classifyStartupSurface,
   cmuxLocal: () => cmuxLocal,
+  confirmedSendToPane: () => confirmedSendToPane,
   createCmuxDriver: () => createCmuxDriver,
   createCmuxNotifier: () => createCmuxNotifier,
   createObsidianDriver: () => createObsidianDriver,
@@ -3183,8 +4022,8 @@ var init_registry4 = __esm({
 });
 
 // packages/agents/dist/drivers/launch-cmd.js
-import fs12 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path12 from "path";
 function buildAgentCmd(agentName, registry, role, fresh, permissionMode, model, templatesDir) {
   const driver = registry.getDriver(agentName);
   if (driver.name === "claude") {
@@ -3200,27 +4039,27 @@ function buildAgentCmd(agentName, registry, role, fresh, permissionMode, model,
       cmd += ` --model ${model}`;
     }
     if (templatesDir) {
-      const roleFile2 = path11.join(templatesDir, `${role}.claude.md`);
-      const legacyRoleFile = path11.join(templatesDir, `${role}.CLAUDE.md`);
-      const actualRoleFile = fs12.existsSync(roleFile2) ? roleFile2 : fs12.existsSync(legacyRoleFile) ? legacyRoleFile : null;
+      const roleFile2 = path12.join(templatesDir, `${role}.claude.md`);
+      const legacyRoleFile = path12.join(templatesDir, `${role}.CLAUDE.md`);
+      const actualRoleFile = fs14.existsSync(roleFile2) ? roleFile2 : fs14.existsSync(legacyRoleFile) ? legacyRoleFile : null;
       if (actualRoleFile) {
         cmd += ` --append-system-prompt-file ${actualRoleFile}`;
       }
-      const pluginDir = path11.join(templatesDir, "..", "plugin");
-      if (fs12.existsSync(pluginDir)) {
+      const pluginDir = path12.join(templatesDir, "..", "plugin");
+      if (fs14.existsSync(pluginDir)) {
         cmd += ` --plugin-dir ${pluginDir}`;
       }
     }
     return cmd;
   }
-  const roleFile = templatesDir ? path11.join(templatesDir, `${role}.${driver.templateSuffix}.md`) : void 0;
+  const roleFile = templatesDir ? path12.join(templatesDir, `${role}.${driver.templateSuffix}.md`) : void 0;
   return driver.buildCommand({
     prompt: `You are a squadrant ${role}. Read your instructions from ${roleFile ?? role} and begin.`,
     workdir: process.cwd(),
     role,
     model,
     autoApprove: true,
-    promptFile: roleFile && fs12.existsSync(roleFile) ? roleFile : void 0
+    promptFile: roleFile && fs14.existsSync(roleFile) ? roleFile : void 0
   });
 }
 var init_launch_cmd = __esm({
@@ -3243,8 +4082,8 @@ var init_drivers = __esm({
 
 // packages/agents/dist/projection/cursor.js
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path12 from "path";
-import os4 from "os";
+import path13 from "path";
+import os5 from "os";
 function renderMdc(source) {
   const skillSections = source.skills.map((s) => `## Skill: ${s.name}
 
@@ -3292,7 +4131,7 @@ function createCursorEmitter() {
       if (scope === "user") {
         return [
           {
-            path: path12.join(os4.homedir(), ".cursor/rules/squadrant-global.mdc"),
+            path: path13.join(os5.homedir(), ".cursor/rules/squadrant-global.mdc"),
             shared: false,
             format: "mdc"
           }
@@ -3302,7 +4141,7 @@ function createCursorEmitter() {
         return [];
       return [
         {
-          path: path12.join(projectRoot, ".cursor/rules/squadrant.mdc"),
+          path: path13.join(projectRoot, ".cursor/rules/squadrant.mdc"),
           shared: false,
           format: "mdc"
         }
@@ -3319,7 +4158,7 @@ function createCursorEmitter() {
           diff: buildDiff(existing, generated)
         };
       }
-      await mkdir(path12.dirname(dest.path), { recursive: true });
+      await mkdir(path13.dirname(dest.path), { recursive: true });
       await writeFile(dest.path, generated, "utf-8");
       return {
         written: true,
@@ -3370,8 +4209,8 @@ var init_marker = __esm({
 
 // packages/agents/dist/projection/codex.js
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path13 from "path";
-import os5 from "os";
+import path14 from "path";
+import os6 from "os";
 function renderMarkdown(source) {
   const skillSections = source.skills.map((s) => `## Skill: ${s.name}
 
@@ -3395,7 +4234,7 @@ function createCodexEmitter() {
     destinations(scope, projectRoot) {
       if (scope === "user") {
         return [{
-          path: path13.join(os5.homedir(), ".codex/AGENTS.md"),
+          path: path14.join(os6.homedir(), ".codex/AGENTS.md"),
           shared: true,
           format: "markdown"
         }];
@@ -3403,7 +4242,7 @@ function createCodexEmitter() {
       if (!projectRoot)
         return [];
       return [{
-        path: path13.join(projectRoot, "AGENTS.md"),
+        path: path14.join(projectRoot, "AGENTS.md"),
         shared: true,
         format: "markdown"
       }];
@@ -3424,7 +4263,7 @@ ${existing ?? ""}
 ${generated}`
         };
       }
-      await mkdir2(path13.dirname(dest.path), { recursive: true });
+      await mkdir2(path14.dirname(dest.path), { recursive: true });
       await writeFile2(dest.path, generated, "utf-8");
       return {
         written: true,
@@ -3442,8 +4281,8 @@ var init_codex2 = __esm({
 
 // packages/agents/dist/projection/gemini.js
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path14 from "path";
-import os6 from "os";
+import path15 from "path";
+import os7 from "os";
 function renderMarkdown2(source) {
   const skillSections = source.skills.map((s) => `## Skill: ${s.name}
 
@@ -3467,7 +4306,7 @@ function createGeminiEmitter() {
     destinations(scope, projectRoot) {
       if (scope === "user") {
         return [{
-          path: path14.join(os6.homedir(), ".gemini/GEMINI.md"),
+          path: path15.join(os7.homedir(), ".gemini/GEMINI.md"),
           shared: true,
           format: "markdown"
         }];
@@ -3475,7 +4314,7 @@ function createGeminiEmitter() {
       if (!projectRoot)
         return [];
       return [{
-        path: path14.join(projectRoot, "GEMINI.md"),
+        path: path15.join(projectRoot, "GEMINI.md"),
         shared: true,
         format: "markdown"
       }];
@@ -3496,7 +4335,7 @@ ${existing ?? ""}
 ${generated}`
         };
       }
-      await mkdir3(path14.dirname(dest.path), { recursive: true });
+      await mkdir3(path15.dirname(dest.path), { recursive: true });
       await writeFile3(dest.path, generated, "utf-8");
       return {
         written: true,
@@ -3514,8 +4353,8 @@ var init_gemini2 = __esm({
 
 // packages/agents/dist/projection/opencode.js
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import path15 from "path";
-import os7 from "os";
+import path16 from "path";
+import os8 from "os";
 function renderMarkdown3(source) {
   const skillSections = source.skills.map((s) => `## Skill: ${s.name}
 
@@ -3539,7 +4378,7 @@ function createOpencodeEmitter() {
     destinations(scope, projectRoot) {
       if (scope === "user") {
         return [{
-          path: path15.join(os7.homedir(), ".config", "opencode", "AGENTS.md"),
+          path: path16.join(os8.homedir(), ".config", "opencode", "AGENTS.md"),
           shared: true,
           format: "markdown"
         }];
@@ -3547,7 +4386,7 @@ function createOpencodeEmitter() {
       if (!projectRoot)
         return [];
       return [{
-        path: path15.join(projectRoot, "AGENTS.md"),
+        path: path16.join(projectRoot, "AGENTS.md"),
         shared: true,
         format: "markdown"
       }];
@@ -3568,7 +4407,7 @@ ${existing ?? ""}
 ${generated}`
         };
       }
-      await mkdir4(path15.dirname(dest.path), { recursive: true });
+      await mkdir4(path16.dirname(dest.path), { recursive: true });
       await writeFile4(dest.path, generated, "utf-8");
       return {
         written: true,
@@ -3809,11 +4648,11 @@ var init_app_server_client = __esm({
 
 // packages/agents/dist/codex/config.js
 import { readFile as readFile5 } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { join as join12 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join14 } from "path";
 async function resolveCodexModel() {
-  const home = process.env["CODEX_HOME"] ?? join12(homedir7(), ".codex");
-  const configPath = join12(home, "config.toml");
+  const home = process.env["CODEX_HOME"] ?? join14(homedir9(), ".codex");
+  const configPath = join14(home, "config.toml");
   let text;
   try {
     text = await readFile5(configPath, "utf8");
@@ -4335,8 +5174,8 @@ var init_sse_bridge = __esm({
 // packages/agents/dist/interactive/claude.js
 import { execSync as execSync7 } from "child_process";
 import { readFileSync as readFileSync8 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join13 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join15 } from "path";
 function probeClaudeSettingsFlag() {
   try {
     const help = execSync7("claude --help", { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
@@ -4387,7 +5226,7 @@ function deriveTranscriptPath(sessionId, cwd) {
   if (!sessionId || !cwd)
     return null;
   const escaped = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-  return join13(homedir8(), ".claude", "projects", escaped, `${sessionId}.jsonl`);
+  return join15(homedir10(), ".claude", "projects", escaped, `${sessionId}.jsonl`);
 }
 function readLastAssistantText(transcriptPath) {
   try {
@@ -4846,18 +5685,18 @@ init_dist();
 init_dist3();
 import { Command } from "commander";
 import { execSync as execSync8 } from "child_process";
-import fs13 from "fs";
+import fs15 from "fs";
 import { stat } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 import chalk3 from "chalk";
 
 // packages/cli/src/commands/health-view.ts
 init_dist2();
 init_dist2();
-import { homedir as homedir6 } from "os";
-import { join as join11 } from "path";
+import { homedir as homedir8 } from "os";
+import { join as join13 } from "path";
 import chalk2 from "chalk";
-var SOCK = join11(homedir6(), ".config", "squadrant", "squadrant.sock");
+var SOCK = join13(homedir8(), ".config", "squadrant", "squadrant.sock");
 async function queryHealth(project) {
   try {
     const reply = await sendRequest(SOCK, { kind: "health", project });
@@ -4951,7 +5790,7 @@ function settingsHaveAgentTeams() {
   try {
     const home = process.env.HOME || "";
     const settings = JSON.parse(
-      fs13.readFileSync(`${home}/.claude/settings.json`, "utf-8")
+      fs15.readFileSync(`${home}/.claude/settings.json`, "utf-8")
     );
     return settings?.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === "1";
   } catch {
@@ -4962,7 +5801,7 @@ function pluginInstalled(pluginKey) {
   try {
     const home = process.env.HOME || "";
     const plugins = JSON.parse(
-      fs13.readFileSync(
+      fs15.readFileSync(
         `${home}/.claude/plugins/installed_plugins.json`,
         "utf-8"
       )
@@ -5007,7 +5846,7 @@ var doctorCommand = new Command("doctor").description("Check system health and p
   ));
   results.push(check(
     "Obsidian installed",
-    commandExists("obsidian") || fs13.existsSync("/Applications/Obsidian.app"),
+    commandExists("obsidian") || fs15.existsSync("/Applications/Obsidian.app"),
     "Install from: https://obsidian.md"
   ));
   results.push(check(
@@ -5101,7 +5940,7 @@ var doctorCommand = new Command("doctor").description("Check system health and p
     const emitter = projectionRegistry.get(name);
     const [userDest] = emitter.destinations("user");
     if (!userDest) continue;
-    const dir = path16.dirname(userDest.path);
+    const dir = path17.dirname(userDest.path);
     let status;
     try {
       await stat(dir);
@@ -5114,7 +5953,7 @@ var doctorCommand = new Command("doctor").description("Check system health and p
   results.push(
     check(
       "Squadrant config exists",
-      fs13.existsSync(
+      fs15.existsSync(
         process.env.SQUADRANT_CONFIG || `${process.env.HOME}/.config/squadrant/config.json`
       ),
       "Run: squadrant init"
@@ -5189,28 +6028,28 @@ init_dist3();
 init_dist();
 init_dist4();
 import { Command as Command2 } from "commander";
-import fs14 from "fs";
-import path17 from "path";
-import os8 from "os";
+import fs16 from "fs";
+import path18 from "path";
+import os9 from "os";
 import readline from "readline";
 import chalk4 from "chalk";
 function findPackageRoot() {
-  let dir = path17.dirname(new URL(import.meta.url).pathname);
+  let dir = path18.dirname(new URL(import.meta.url).pathname);
   while (dir !== "/") {
-    if (fs14.existsSync(path17.join(dir, "package.json"))) return dir;
-    dir = path17.dirname(dir);
+    if (fs16.existsSync(path18.join(dir, "package.json"))) return dir;
+    dir = path18.dirname(dir);
   }
   return process.cwd();
 }
 function copyDirRecursive(src, dest) {
-  fs14.mkdirSync(dest, { recursive: true });
-  for (const entry of fs14.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path17.join(src, entry.name);
-    const destPath = path17.join(dest, entry.name);
+  fs16.mkdirSync(dest, { recursive: true });
+  for (const entry of fs16.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path18.join(src, entry.name);
+    const destPath = path18.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs14.copyFileSync(srcPath, destPath);
+      fs16.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -5230,7 +6069,7 @@ function promptLine(question) {
 var initCommand = new Command2("init").description("Guided first-time setup: hub vault, agents, plugins, projects (re-run-safe)").option("--hub <path>", "Hub vault path", "~/squadrant-hub").action(async (opts) => {
   const hubPath = resolveHome(opts.hub);
   const pkgRoot = findPackageRoot();
-  const configDir = path17.join(os8.homedir(), ".config", "squadrant");
+  const configDir = path18.join(os9.homedir(), ".config", "squadrant");
   const isTTY = process.stdin.isTTY === true;
   console.log(chalk4.bold("\nSquadrant Init\n"));
   if (!isTTY) {
@@ -5253,8 +6092,8 @@ var initCommand = new Command2("init").description("Guided first-time setup: hub
   }
   const wsRegistry = new WorkspaceRegistry({ obsidian: createObsidianDriver });
   try {
-    if (fs14.existsSync(DEFAULT_CONFIG_PATH)) {
-      const existing = JSON.parse(fs14.readFileSync(DEFAULT_CONFIG_PATH, "utf-8"));
+    if (fs16.existsSync(DEFAULT_CONFIG_PATH)) {
+      const existing = JSON.parse(fs16.readFileSync(DEFAULT_CONFIG_PATH, "utf-8"));
       wsRegistry.get(existing.workspace ?? "obsidian");
     }
   } catch (err) {
@@ -5262,7 +6101,7 @@ var initCommand = new Command2("init").description("Guided first-time setup: hub
     return;
   }
   stepHeader(1, 5, "Hub vault");
-  if (fs14.existsSync(DEFAULT_CONFIG_PATH)) {
+  if (fs16.existsSync(DEFAULT_CONFIG_PATH)) {
     console.log(chalk4.yellow("    \u26A0 Config already exists, skipping creation"));
   } else {
     const config = getDefaultConfig();
@@ -5270,37 +6109,37 @@ var initCommand = new Command2("init").description("Guided first-time setup: hub
     saveConfig(config);
     console.log(chalk4.green(`    \u2714 Config created at ${DEFAULT_CONFIG_PATH}`));
   }
-  const hubTemplate = path17.join(pkgRoot, "obsidian", "hub");
-  if (fs14.existsSync(hubPath)) {
+  const hubTemplate = path18.join(pkgRoot, "obsidian", "hub");
+  if (fs16.existsSync(hubPath)) {
     console.log(chalk4.yellow(`    \u26A0 Hub vault already exists at ${hubPath}`));
-  } else if (fs14.existsSync(hubTemplate)) {
+  } else if (fs16.existsSync(hubTemplate)) {
     copyDirRecursive(hubTemplate, hubPath);
     console.log(chalk4.green(`    \u2714 Hub vault scaffolded at ${hubPath}`));
   } else {
-    fs14.mkdirSync(hubPath, { recursive: true });
+    fs16.mkdirSync(hubPath, { recursive: true });
     console.log(chalk4.yellow(`    \u26A0 Hub template not found; created empty directory at ${hubPath}`));
   }
-  const hubDashboardSrc = path17.join(pkgRoot, "obsidian", "hub", "dashboard.md");
-  const hubDashboardDest = path17.join(hubPath, "dashboard.md");
-  if (fs14.existsSync(hubDashboardSrc)) {
-    fs14.copyFileSync(hubDashboardSrc, hubDashboardDest);
+  const hubDashboardSrc = path18.join(pkgRoot, "obsidian", "hub", "dashboard.md");
+  const hubDashboardDest = path18.join(hubPath, "dashboard.md");
+  if (fs16.existsSync(hubDashboardSrc)) {
+    fs16.copyFileSync(hubDashboardSrc, hubDashboardDest);
     console.log(chalk4.green(`    \u2714 Dashboard refreshed`));
   }
-  fs14.mkdirSync(path17.join(hubPath, "projects"), { recursive: true });
+  fs16.mkdirSync(path18.join(hubPath, "projects"), { recursive: true });
   ensureRuntimeSynced({ sourceRoot: pkgRoot, runtimeRoot: configDir });
   console.log(chalk4.green(`    \u2714 Runtime assets synced to ${configDir}`));
   stepHeader(2, 5, "Agent + projection setup");
-  const settingsPath = path17.join(os8.homedir(), ".claude", "settings.json");
+  const settingsPath = path18.join(os9.homedir(), ".claude", "settings.json");
   try {
     let settings = {};
-    if (fs14.existsSync(settingsPath)) {
-      settings = JSON.parse(fs14.readFileSync(settingsPath, "utf-8"));
+    if (fs16.existsSync(settingsPath)) {
+      settings = JSON.parse(fs16.readFileSync(settingsPath, "utf-8"));
     }
     const env = settings.env || {};
     if (env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS !== "1") {
       settings.env = { ...env, CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1" };
-      fs14.mkdirSync(path17.dirname(settingsPath), { recursive: true });
-      fs14.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      fs16.mkdirSync(path18.dirname(settingsPath), { recursive: true });
+      fs16.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
       console.log(chalk4.green("    \u2714 Agent Teams enabled in ~/.claude/settings.json"));
     } else {
       console.log(chalk4.green("    \u2714 Agent Teams already enabled"));
@@ -5343,7 +6182,7 @@ var initCommand = new Command2("init").description("Guided first-time setup: hub
     chalk4.cyan("    Absolute path to your first project (Enter to skip): ")
   );
   if (projectPath) {
-    const projectName = path17.basename(projectPath);
+    const projectName = path18.basename(projectPath);
     console.log(chalk4.bold(`
     Run this to register it:`));
     console.log(chalk4.cyan(`      squadrant projects add ${projectName} ${projectPath}
@@ -5369,45 +6208,11 @@ var initCommand = new Command2("init").description("Guided first-time setup: hub
 
 // packages/cli/src/commands/projects.ts
 init_dist();
+init_dist2();
 import { Command as Command3 } from "commander";
-import fs15 from "fs";
-import path18 from "path";
+import fs17 from "fs";
+import path19 from "path";
 import chalk5 from "chalk";
-
-// packages/cli/src/control/restart-daemon.ts
-init_dist2();
-import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join14 } from "path";
-var DEFAULT_SOCK_PATH = join14(homedir9(), ".config", "squadrant", "squadrant.sock");
-function defaultIsRunning() {
-  return existsSync9(DEFAULT_SOCK_PATH);
-}
-function defaultRunKickstart() {
-  const uid = process.getuid?.() ?? 0;
-  const target = `gui/${uid}/${LABEL}`;
-  if (tryAcquireDaemonLock()) {
-    try {
-      execFileSync6("launchctl", kickstartArgv(target, true), { stdio: "ignore" });
-    } finally {
-      releaseDaemonLock();
-    }
-  }
-}
-function restartDaemonIfRunning(opts) {
-  const env = opts.env ?? process.env;
-  if (env["VITEST"] || opts.noRestart) return "skipped-opt-out";
-  const isRunning = opts.isRunning ?? defaultIsRunning;
-  if (!isRunning()) return "skipped-not-running";
-  const log = opts.log ?? console.log;
-  log(`\u21BB restarting daemon to apply ${opts.reason}\u2026`);
-  const runKickstart = opts.runKickstart ?? defaultRunKickstart;
-  runKickstart();
-  return "restarted";
-}
-
-// packages/cli/src/commands/projects.ts
 function restartAfterProjectsAdd(opts) {
   const doRestart = opts.doRestart ?? restartDaemonIfRunning;
   const outcome = doRestart({ reason: "project registration", noRestart: opts.noRestart });
@@ -5418,22 +6223,22 @@ function restartAfterProjectsAdd(opts) {
   }
 }
 function findPackageRoot2() {
-  let dir = path18.dirname(new URL(import.meta.url).pathname);
+  let dir = path19.dirname(new URL(import.meta.url).pathname);
   while (dir !== "/") {
-    if (fs15.existsSync(path18.join(dir, "package.json"))) return dir;
-    dir = path18.dirname(dir);
+    if (fs17.existsSync(path19.join(dir, "package.json"))) return dir;
+    dir = path19.dirname(dir);
   }
   return process.cwd();
 }
 function copyDirRecursive2(src, dest) {
-  fs15.mkdirSync(dest, { recursive: true });
-  for (const entry of fs15.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path18.join(src, entry.name);
-    const destPath = path18.join(dest, entry.name);
+  fs17.mkdirSync(dest, { recursive: true });
+  for (const entry of fs17.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path19.join(src, entry.name);
+    const destPath = path19.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive2(srcPath, destPath);
     } else {
-      fs15.copyFileSync(srcPath, destPath);
+      fs17.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -5469,7 +6274,7 @@ var addCmd = new Command3("add").description("Register a project").argument("<na
     process.exit(1);
   }
   const resolvedPath = resolveHome(projectPath);
-  if (!fs15.existsSync(path18.join(resolvedPath, ".git"))) {
+  if (!fs17.existsSync(path19.join(resolvedPath, ".git"))) {
     console.log(chalk5.yellow(`
   \u26A0 No .git found at ${resolvedPath}. Make sure this is the project root, not a parent directory.
 `));
@@ -5522,7 +6327,7 @@ var addCmd = new Command3("add").description("Register a project").argument("<na
   \u26A0 Group '${group}' already has '${primary[0]}' as primary. Overriding.`));
     }
   }
-  const spokeVault = opts.spoke ? resolveHome(opts.spoke) : path18.join(config.hubVault, "spokes", name);
+  const spokeVault = opts.spoke ? resolveHome(opts.spoke) : path19.join(config.hubVault, "spokes", name);
   const project = {
     path: resolvedPath,
     captainName,
@@ -5537,20 +6342,20 @@ var addCmd = new Command3("add").description("Register a project").argument("<na
   \u2714 Project '${name}' registered`));
   restartAfterProjectsAdd({ noRestart: opts.restart === false });
   const pkgRoot = findPackageRoot2();
-  const spokeTemplate = path18.join(pkgRoot, "obsidian", "spoke");
-  if (fs15.existsSync(spokeVault)) {
+  const spokeTemplate = path19.join(pkgRoot, "obsidian", "spoke");
+  if (fs17.existsSync(spokeVault)) {
     console.log(chalk5.yellow(`  \u26A0 Spoke vault already exists at ${spokeVault}, skipping scaffold`));
-  } else if (fs15.existsSync(spokeTemplate)) {
+  } else if (fs17.existsSync(spokeTemplate)) {
     copyDirRecursive2(spokeTemplate, spokeVault);
-    const statusPath = path18.join(spokeVault, "status.md");
-    if (fs15.existsSync(statusPath)) {
-      const content = fs15.readFileSync(statusPath, "utf-8");
+    const statusPath = path19.join(spokeVault, "status.md");
+    if (fs17.existsSync(statusPath)) {
+      const content = fs17.readFileSync(statusPath, "utf-8");
       const updated = content.replace(/^project: unnamed/m, `project: ${name}`);
-      fs15.writeFileSync(statusPath, updated);
+      fs17.writeFileSync(statusPath, updated);
     }
     console.log(chalk5.green(`  \u2714 Spoke vault scaffolded at ${spokeVault}`));
   } else {
-    fs15.mkdirSync(spokeVault, { recursive: true });
+    fs17.mkdirSync(spokeVault, { recursive: true });
     console.log(chalk5.yellow(`  \u26A0 Spoke template not found; created empty dir at ${spokeVault}`));
   }
   console.log("");
@@ -5651,10 +6456,10 @@ init_dist4();
 init_dist();
 import { Command as Command5 } from "commander";
 import { execSync as execSync9 } from "child_process";
-import path19 from "path";
-import os9 from "os";
+import path20 from "path";
+import os10 from "os";
 import chalk7 from "chalk";
-var TEMPLATES_DIR = path19.join(os9.homedir(), ".config", "squadrant", "templates");
+var TEMPLATES_DIR2 = path20.join(os10.homedir(), ".config", "squadrant", "templates");
 var TASK_PROMPTS = {
   briefing: "Run your daily briefing using the squadrant:command-ops skill. Read all spoke handoffs, yesterday's logs, current status; produce a concise cross-project briefing; save to {hubVault}/daily-logs/YYYY-MM-DD.md; then exit.",
   "learnings-review": "Run a learnings review using the squadrant:command-ops skill. Scan {spokeVault}/learnings across all projects, identify cross-project patterns, propose captured-skill or fix actions, and exit when done.",
@@ -5687,7 +6492,7 @@ async function runCommandSpawn(input) {
   if (!agent) {
     throw new Error(`Unknown agent '${agentName}'. Known: claude, codex, gemini, opencode.`);
   }
-  const promptFile = path19.join(TEMPLATES_DIR, `command.${agent.templateSuffix}.md`);
+  const promptFile = path20.join(TEMPLATES_DIR2, `command.${agent.templateSuffix}.md`);
   const cliCommand = agent.buildCommand({
     prompt,
     workdir: process.cwd(),
@@ -5712,35 +6517,11 @@ var commandCommand = new Command5("command").description("Spawn a one-shot Comma
 
 // packages/cli/src/commands/crew.ts
 init_dist();
-init_dist();
-import { Command as Command9 } from "commander";
-import fs16 from "fs";
-import path20 from "path";
-import os10 from "os";
-import chalk9 from "chalk";
-
-// packages/cli/src/control/crew-routing.ts
-function resolveCrewRoute(taskText, config) {
-  const rules = config.defaults.crewRouting?.rules;
-  if (!rules || rules.length === 0) return null;
-  for (const rule2 of rules) {
-    const re = new RegExp(rule2.match, "i");
-    if (re.test(taskText)) {
-      return {
-        agent: rule2.agent,
-        ...rule2.model !== void 0 ? { model: rule2.model } : {},
-        tier: rule2.tier,
-        matchedRule: rule2.match
-      };
-    }
-  }
-  return null;
-}
-
-// packages/cli/src/commands/crew.ts
-init_dist3();
 init_dist3();
 init_dist4();
+init_dist2();
+import { Command as Command9 } from "commander";
+import chalk9 from "chalk";
 
 // packages/cli/src/commands/crew-control.ts
 init_dist2();
@@ -5748,9 +6529,9 @@ init_dist2();
 init_dist4();
 import { Command as Command8 } from "commander";
 import { createConnection as createConnection3 } from "net";
-import { randomUUID as randomUUID3 } from "crypto";
-import { homedir as homedir11 } from "os";
-import { join as join16 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { homedir as homedir12 } from "os";
+import { join as join17 } from "path";
 import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
 
 // packages/cli/src/commands/crew-output.ts
@@ -5809,11 +6590,11 @@ init_dist2();
 import { Command as Command6 } from "commander";
 import chalk8 from "chalk";
 import { createConnection as createConnection2 } from "net";
-import { homedir as homedir10 } from "os";
-import { join as join15 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join16 } from "path";
 import { createInterface } from "readline";
 function socketPath() {
-  return process.env.SQUADRANTD_SOCK ?? join15(homedir10(), ".config", "squadrant", "squadrant.sock");
+  return process.env.SQUADRANTD_SOCK ?? join16(homedir11(), ".config", "squadrant", "squadrant.sock");
 }
 function rule(width, ch = "\u2500") {
   return ch.repeat(Math.max(0, width));
@@ -6038,7 +6819,7 @@ var crewChatCommand = new Command7("chat").description("[DEPRECATED] alias for `
   if (opts.provider !== "codex") {
     throw new Error(`crew chat is implemented for provider=codex only (got '${opts.provider}')`);
   }
-  const pane = await runCrewSpawn({
+  const pane = await runCrewSpawn2({
     project: opts.project,
     task: "(interactive)",
     agent: "codex",
@@ -6049,7 +6830,7 @@ var crewChatCommand = new Command7("chat").description("[DEPRECATED] alias for `
 });
 
 // packages/cli/src/commands/crew-control.ts
-var SOCK2 = join16(homedir11(), ".config", "squadrant", "squadrant.sock");
+var SOCK2 = join17(homedir12(), ".config", "squadrant", "squadrant.sock");
 var CODEX_FIRST_TURN_DELAY_MS = 1500;
 async function sendCodexFirstTurn(taskId, text) {
   await new Promise((r) => setTimeout(r, CODEX_FIRST_TURN_DELAY_MS));
@@ -6076,11 +6857,11 @@ async function sendCodexFirstTurn(taskId, text) {
 }
 function buildDispatchRequest(o) {
   const now = Date.now();
-  const attemptId = randomUUID3();
+  const attemptId = randomUUID4();
   return {
     kind: "dispatch",
     record: {
-      id: randomUUID3(),
+      id: randomUUID4(),
       project: o.project,
       provider: o.provider,
       mode: o.mode,
@@ -6154,9 +6935,9 @@ function buildSignalRequest(signal, o) {
   return { kind: "event", project, event };
 }
 function defaultWriteResult(id, payload) {
-  const dir = join16(homedir11(), ".config", "squadrant", "state", "_results");
+  const dir = join17(homedir12(), ".config", "squadrant", "state", "_results");
   mkdirSync6(dir, { recursive: true });
-  const file = join16(dir, `${id}.txt`);
+  const file = join17(dir, `${id}.txt`);
   writeFileSync7(file, payload);
   return file;
 }
@@ -6257,7 +7038,7 @@ addControlPlaneCrewCommands(crewControlCommand);
 // packages/cli/src/lib/per-crew-settings.ts
 init_dist4();
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var CREW_PERMISSION_ALLOWLIST = [
   // git — read + safe mutations (reset/clean/config intentionally excluded)
   "Bash(git status:*)",
@@ -6348,9 +7129,9 @@ function mergeCrewPermissions(settings) {
   return next;
 }
 function writePerCrewSettingsLocal(o) {
-  const dir = join17(o.projectCwd, ".claude");
+  const dir = join18(o.projectCwd, ".claude");
   mkdirSync7(dir, { recursive: true });
-  const file = join17(dir, "settings.local.json");
+  const file = join18(dir, "settings.local.json");
   let existing = {};
   try {
     const raw = healStaleCockpitRefs(readFileSync9(file, "utf-8"));
@@ -6363,304 +7144,89 @@ function writePerCrewSettingsLocal(o) {
   return file;
 }
 function writePerCrewOpencodeConfig(o) {
-  const dir = join17(o.stateRoot, o.project, o.taskId);
+  const dir = join18(o.stateRoot, o.project, o.taskId);
   mkdirSync7(dir, { recursive: true });
-  const file = join17(dir, "opencode.json");
+  const file = join18(dir, "opencode.json");
   const config = {
     permission: {
       read: "allow",
       edit: "allow",
       glob: "allow",
-      grep: "allow",
-      bash: o.gateBash ? "ask" : "allow",
-      webfetch: "allow",
-      websearch: "allow",
-      task: "allow",
-      lsp: "allow",
-      external_directory: { "**": "allow" }
-    }
-  };
-  writeFileSync8(file, JSON.stringify(config, null, 2));
-  return file;
-}
-
-// packages/cli/src/commands/crew.ts
-init_dist2();
-var TEMPLATES_DIR2 = path20.join(os10.homedir(), ".config", "squadrant", "templates");
-async function runCrewSpawn(input) {
-  const config = loadConfig();
-  const proj = config.projects[input.project];
-  if (!proj) {
-    throw new Error(`Project '${input.project}' not found. Run 'squadrant projects list'.`);
-  }
-  const runtime = new RuntimeRegistry({ cmux: createCmuxDriver() }).forProject(input.project, config);
-  const captain = await runtime.status(proj.captainName);
-  if (!captain) {
-    throw new Error(
-      `Captain workspace '${proj.captainName}' is not running. Run 'squadrant launch ${input.project}' first.`
-    );
-  }
-  const existing = await listProjectCrews(runtime, captain.id, input.project);
-  const existingTitles = existing.map((s) => s.title);
-  if (input.name) {
-    const wantTitle = titleFor(input.project, input.name);
-    if (existingTitles.includes(wantTitle)) {
-      throw new Error(
-        `Crew '${input.name}' already exists for ${input.project}. Use 'squadrant crew send ${input.project} ${input.name}' to send a follow-up, or pick a different --name.`
-      );
-    }
-  }
-  const name = input.name ?? nextAutoName(existingTitles, input.project);
-  const spawnCwd = !input.shared ? addWorktree({
-    repoRoot: proj.path,
-    worktreeDir: config.defaults.worktreeDir ?? ".worktrees",
-    project: input.project,
-    name,
-    base: resolveWorktreeBase(proj.path)
-  }) : proj.path;
-  const route = !input.agentExplicit && !input.model ? resolveCrewRoute(input.task, config) : null;
-  if (route) {
-    console.log(chalk9.dim(`routed: tier=${route.tier} \u2192 ${route.agent}${route.model ? `/${route.model}` : ""} (rule: "${route.matchedRule}")`));
-  }
+      grep: "allow",
+      bash: o.gateBash ? "ask" : "allow",
+      webfetch: "allow",
+      websearch: "allow",
+      task: "allow",
+      lsp: "allow",
+      external_directory: { "**": "allow" }
+    }
+  };
+  writeFileSync8(file, JSON.stringify(config, null, 2));
+  return file;
+}
+
+// packages/cli/src/commands/crew.ts
+async function runCrewSpawn2(input) {
+  const config = loadConfig();
+  const runtime = new RuntimeRegistry({ cmux: createCmuxDriver() }).forProject(input.project, config);
   const agents = new CapabilityRegistry({
     claude: createClaudeDriver(),
     codex: createCodexDriver(),
     gemini: createGeminiDriver(),
     opencode: createOpencodeDriver()
   });
-  const agentName = route?.agent ?? input.agent ?? "claude";
-  const agent = agents.get(agentName);
-  if (!agent) {
-    throw new Error(`Unknown agent '${agentName}'. Known: claude, codex, gemini, opencode.`);
-  }
-  if (agentName === "codex") {
-    const codexRoleFile = path20.join(TEMPLATES_DIR2, `crew.${agent.templateSuffix}.md`);
-    const roleInstructions = fs16.existsSync(codexRoleFile) ? fs16.readFileSync(codexRoleFile, "utf8") : void 0;
-    return runCodexInteractiveSpawn({
-      project: input.project,
-      task: input.task,
-      cwd: spawnCwd,
-      runtime,
-      workspaceId: captain.id,
-      name,
-      direction: input.direction ?? "tab",
-      approvalPolicy: input.approvalPolicy,
-      roleInstructions
-    });
-  }
-  const promptFile = path20.join(TEMPLATES_DIR2, `crew.${agent.templateSuffix}.md`);
-  const interactive = agent.name === "claude" || agent.name === "opencode";
-  const crewRole = config.defaults.roles?.crew;
-  const configModel = crewRole && crewRole.agent === agent.name ? crewRole.model : void 0;
-  const crewModel = input.model ?? route?.model ?? configModel;
-  if (agentName === "claude") {
-    const req = buildDispatchRequest({
-      provider: "claude",
-      mode: "interactive",
-      project: input.project,
-      cwd: spawnCwd,
-      task: input.task,
-      name
-    });
-    const rec = await squadrantdCall(req);
-    writePerCrewSettingsLocal({ projectCwd: spawnCwd });
-    const cliCommand2 = agent.buildCommand({
-      prompt: input.task,
-      workdir: spawnCwd,
-      role: "crew",
-      promptFile,
-      interactive: true,
-      // Permission mode is config-driven (defaults.permissions.crew) so squadrant
-      // can default crews to 'auto' or keep the semi-automatic 'acceptEdits'
-      // gate (auto-accept edits, still prompt for risky ops). Falls back to
-      // 'acceptEdits' when unset.
-      permissionMode: config.defaults.permissions?.crew ?? "acceptEdits",
-      ...crewModel ? { model: crewModel } : {}
-    });
-    const direction2 = input.direction ?? "tab";
-    const title2 = titleFor(input.project, name);
-    const pane2 = await runtime.newPane({ workspaceId: captain.id, direction: direction2, title: title2 });
-    const envPrefix = `SQUADRANT_CREW_TASK_ID=${rec.id} SQUADRANT_CREW_PROJECT=${input.project}`;
-    await runtime.sendToPane(pane2, `cd ${shellQuote(spawnCwd)} && ${envPrefix} ${cliCommand2}`);
-    const preLaunchScreen = await runtime.readPaneScreen(pane2) ?? "";
-    await sendFirstTurnWhenReady(runtime, pane2, `${input.task}
-
-${buildCompletionProtocol(rec.id, input.project)}`, preLaunchScreen);
-    return { ...pane2, title: title2 };
-  }
-  if (agentName === "opencode") {
-    const serverPort = await getFreePort();
-    const req = buildDispatchRequest({
-      provider: "opencode",
-      mode: "interactive",
-      project: input.project,
-      cwd: spawnCwd,
-      task: input.task,
-      name,
-      // opencode has no heartbeat hook, so a normal budget would false-stall
-      // every crew after 5min; use a 24h budget to effectively disable stall
-      // detection. The SSE bridge (serverPort) provides turn-end liveness.
-      budgetMs: 864e5,
-      serverPort
-    });
-    const rec = await squadrantdCall(req);
-    const opencodeConfigPath = writePerCrewOpencodeConfig({
-      stateRoot: path20.join(os10.homedir(), ".config", "squadrant", "state"),
-      project: input.project,
-      taskId: rec.id,
-      // CP3 opt-in: --approval gates bash so the captain approves shell commands.
-      // Without it, bash stays auto-approved (default behavior unchanged).
-      ...input.approval ? { gateBash: true } : {}
-    });
-    const cliCommand2 = agent.buildCommand({
-      prompt: input.task,
-      workdir: spawnCwd,
-      role: "crew",
-      promptFile,
-      interactive: true,
-      model: crewModel,
-      port: serverPort
-    });
-    const direction2 = input.direction ?? "tab";
-    const title2 = titleFor(input.project, name);
-    const pane2 = await runtime.newPane({ workspaceId: captain.id, direction: direction2, title: title2 });
-    const envPrefix = `SQUADRANT_CREW_TASK_ID=${rec.id} SQUADRANT_CREW_PROJECT=${input.project}`;
-    await runtime.sendToPane(pane2, `cd ${shellQuote(spawnCwd)} && ${envPrefix} OPENCODE_CONFIG=${opencodeConfigPath} ${cliCommand2}`);
-    const preLaunchScreen = await runtime.readPaneScreen(pane2) ?? "";
-    await sendFirstTurnWhenReady(runtime, pane2, `${input.task}
-
-${buildCompletionProtocol(rec.id, input.project)}`, preLaunchScreen, {
-      // #235: opencode's idle splash ("Ask anything…") keeps mutating (cursor
-      // blink, status line toggle), so the old screen-changed check would always
-      // see a *different* screen and never re-send a dropped turn. The splashMarker
-      // confirms the TUI actually left splash before declaring acceptance.
-      splashMarker: "Ask anything\u2026",
-      // opencode has a wider boot-race window than claude, so allow 3 retries
-      // instead of the default 2.
-      retryLimit: 3
-    });
-    return { ...pane2, title: title2 };
-  }
-  const cliCommand = agent.buildCommand({
-    prompt: input.task,
-    workdir: spawnCwd,
-    role: "crew",
-    promptFile,
-    interactive,
-    model: crewModel
-  });
-  const direction = input.direction ?? "tab";
-  const title = titleFor(input.project, name);
-  const pane = await runtime.newPane({ workspaceId: captain.id, direction, title });
-  await runtime.sendToPane(pane, cliCommand);
-  if (interactive) {
-    const preLaunchScreen = await runtime.readPaneScreen(pane) ?? "";
-    await sendFirstTurnWhenReady(runtime, pane, input.task, preLaunchScreen);
-  }
-  return { ...pane, title };
-}
-async function runCodexInteractiveSpawn(o) {
-  const req = buildDispatchRequest({
-    provider: "codex",
-    mode: "interactive",
-    project: o.project,
-    cwd: o.cwd,
-    task: o.task,
-    name: o.name,
-    ...o.approvalPolicy ? { approvalPolicy: o.approvalPolicy } : {},
-    ...o.roleInstructions ? { roleInstructions: o.roleInstructions } : {}
-  });
-  const rec = await squadrantdCall(req);
-  const title = titleFor(o.project, o.name);
-  const pane = await o.runtime.newPane({
-    workspaceId: o.workspaceId,
-    direction: o.direction,
-    title
+  return runCrewSpawn(input, config, {
+    runtime,
+    // AgentDriver satisfies ResolvedAgent structurally; `role: any` in ResolvedAgent
+    // bridges the Role vs string gap — only "crew" is ever passed at call sites.
+    resolveAgent: (name) => agents.get(name) ?? null,
+    dispatchCrew: async (o) => {
+      const req = buildDispatchRequest(o);
+      return await squadrantdCall(req);
+    },
+    writeSettingsLocal: (cwd) => writePerCrewSettingsLocal({ projectCwd: cwd }),
+    writeOpencodeConfig: writePerCrewOpencodeConfig,
+    sendFirstTurn: (pane, firstTurn, preLaunchScreen, opts) => sendFirstTurnWhenReady(runtime, pane, firstTurn, preLaunchScreen, opts),
+    getFreePort,
+    sendCodexFirstTurn,
+    onRouted: (route) => console.log(
+      chalk9.dim(
+        `routed: tier=${route.tier} \u2192 ${route.agent}${route.model ? `/${route.model}` : ""} (rule: "${route.matchedRule}")`
+      )
+    )
   });
-  await o.runtime.sendToPane(pane, `squadrant crew attach ${rec.id}`);
-  if (o.task && o.task !== "(interactive)") {
-    void sendCodexFirstTurn(rec.id, o.task).catch((e) => {
-      process.stderr.write(`(first-turn delivery failed: ${e.message})
-`);
-    });
-  }
-  return { ...pane, title };
 }
-async function runCrewSend(project, name, message) {
+async function runCrewSend2(project, name, message) {
   const { runtime, workspaceId } = await resolveCaptainWorkspace(project);
-  const crew = await findCrew(runtime, workspaceId, project, name);
-  if (!crew) {
-    throw new Error(`Crew '${name}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
-  }
-  try {
-    const tasks = await squadrantdCall({ kind: "list", project });
-    const task = tasks.find((t) => t.name === name);
-    if (task) {
-      if (TERMINAL_STATES.has(task.state)) {
-        await squadrantdCall({ kind: "event", project, event: { type: "task.reopened", id: task.id } });
-      } else if (task.state === "blocked" || task.state === "awaiting-input") {
-        await squadrantdCall({ kind: "event", project, event: { type: "task.started", id: task.id } });
-      }
-    }
-  } catch {
-  }
-  await runtime.sendToPane(crew, message);
+  return runCrewSend(project, name, message, runtime, workspaceId, {
+    listTasks: async (p) => await squadrantdCall({ kind: "list", project: p }),
+    emitEvent: async (p, event) => {
+      await squadrantdCall({ kind: "event", project: p, event });
+    },
+    // #448: use paste-settle-Enter confirmation for follow-up sends (same guard
+    // as first-turn #447) so large messages don't strand in paste mode.
+    sendToPane: (pane, msg) => confirmedSendToPane(runtime, pane, msg)
+  });
 }
-async function runCrewRead(project, name) {
+async function runCrewRead2(project, name) {
   const { runtime, workspaceId } = await resolveCaptainWorkspace(project);
-  const crew = await findCrew(runtime, workspaceId, project, name);
-  if (!crew) {
-    throw new Error(`Crew '${name}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
-  }
-  return runtime.readPaneScreen(crew);
+  return runCrewRead(project, name, runtime, workspaceId);
 }
-async function runCrewClose(project, name) {
+async function runCrewClose2(project, name) {
   const { runtime, workspaceId } = await resolveCaptainWorkspace(project);
-  const projRoot = loadConfig().projects[project]?.path;
-  let taskId;
-  let worktreeCwd;
-  try {
-    const tasks = await squadrantdCall({ kind: "list", project });
-    const task = tasks.find((t) => t.name === name);
-    if (task) {
-      taskId = task.id;
-      if (task.cwd && projRoot && task.cwd !== projRoot) {
-        worktreeCwd = task.cwd;
-      }
-      if (!TERMINAL_STATES.has(task.state)) {
-        await squadrantdCall({ kind: "event", project, event: { type: "task.cancelled", id: task.id, reason: "closed by captain" } });
-      }
-      if (task.provider === "codex") {
-        await squadrantdCall({ kind: "codex-close", taskId: task.id });
-      }
-    }
-  } catch {
-  }
-  const crew = await findCrew(runtime, workspaceId, project, name);
-  if (crew) {
-    await runtime.closePane(crew);
-  } else if (taskId === void 0) {
-    throw new Error(`Crew '${name}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
-  }
-  if (taskId !== void 0) {
-    await reapCrewChildren(taskId);
-  }
-  if (worktreeCwd && projRoot) {
-    try {
-      removeWorktree(projRoot, worktreeCwd);
-    } catch (e) {
-      process.stderr.write(`(worktree remove failed: ${e.message})
-`);
+  return runCrewClose(project, name, runtime, workspaceId, {
+    listTasks: async (p) => await squadrantdCall({ kind: "list", project: p }),
+    emitEvent: async (p, event) => {
+      await squadrantdCall({ kind: "event", project: p, event });
+    },
+    closeCodexThread: async (taskId) => {
+      await squadrantdCall({ kind: "codex-close", taskId });
     }
-  }
+  });
 }
-async function runCrewList(project) {
+async function runCrewList2(project) {
   const { runtime, workspaceId } = await resolveCaptainWorkspace(project);
-  const crews = await listProjectCrews(runtime, workspaceId, project);
-  return crews.map((c) => ({
-    name: nameFromTitle(project, c.title),
-    surfaceId: c.surfaceId
-  }));
+  return runCrewList(project, runtime, workspaceId);
 }
 var crewCommand = new Command9("crew").description(
   "Spawn and manage interactive crew sessions next to the project's captain"
@@ -6672,7 +7238,7 @@ crewCommand.command("spawn").description(
     try {
       const resolvedTask = await resolveTextInput({ positional: task, filePath: opts.taskFile, label: "task" });
       const agentExplicit = cmd.getOptionValueSource("agent") === "cli";
-      const pane = await runCrewSpawn({
+      const pane = await runCrewSpawn2({
         project,
         task: resolvedTask,
         name: opts.name,
@@ -6694,7 +7260,7 @@ crewCommand.command("spawn").description(
 );
 crewCommand.command("list").description("List live crew sessions for a project").argument("<project>", "Project name").action(async (project) => {
   try {
-    const crews = await runCrewList(project);
+    const crews = await runCrewList2(project);
     if (crews.length === 0) {
       console.log(chalk9.yellow(`No live crew sessions for ${project}.`));
       return;
@@ -6710,7 +7276,7 @@ crewCommand.command("list").description("List live crew sessions for a project")
 crewCommand.command("send").description("Send a follow-up message to an existing crew session").argument("<project>", "Project name").argument("<name>", "Crew name (e.g. crew-1)").argument("[message]", "Message to send (omit with --message-file)").option("--message-file <path>", "Read message from file instead of positional arg ('-' for stdin)").action(async (project, name, message, opts) => {
   try {
     const resolvedMessage = await resolveTextInput({ positional: message, filePath: opts.messageFile, label: "message" });
-    await runCrewSend(project, name, resolvedMessage);
+    await runCrewSend2(project, name, resolvedMessage);
     console.log(chalk9.green(`\u2714 Sent to ${project}:${name}`));
   } catch (err) {
     console.error(chalk9.red(err.message));
@@ -6719,7 +7285,7 @@ crewCommand.command("send").description("Send a follow-up message to an existing
 });
 crewCommand.command("read").description("Read the current screen of a crew session (tail by default; use --full for the entire scrollback)").argument("<project>", "Project name").argument("<name>", "Crew name").option("--lines <N>", "Number of trailing lines to show", "40").option("--full", "Show the entire scrollback (overrides --lines)").action(async (project, name, opts) => {
   try {
-    const screen = await runCrewRead(project, name);
+    const screen = await runCrewRead2(project, name);
     const out = opts.full ? screen : tailLines(screen, Number(opts.lines ?? 40));
     console.log(out);
   } catch (err) {
@@ -6729,7 +7295,7 @@ crewCommand.command("read").description("Read the current screen of a crew sessi
 });
 crewCommand.command("close").description("Shutdown a crew session (closes its tab)").argument("<project>", "Project name").argument("<name>", "Crew name").action(async (project, name) => {
   try {
-    await runCrewClose(project, name);
+    await runCrewClose2(project, name);
     console.log(chalk9.green(`\u2714 Closed ${project}:${name}`));
   } catch (err) {
     console.error(chalk9.red(err.message));
@@ -6743,90 +7309,23 @@ init_dist3();
 init_dist4();
 init_dist3();
 init_dist();
-init_dist();
+init_dist2();
 import { Command as Command10 } from "commander";
-import fs17 from "fs";
+import fs18 from "fs";
 import path21 from "path";
 import os11 from "os";
 import chalk10 from "chalk";
 var TEMPLATES_DIR3 = path21.join(os11.homedir(), ".config", "squadrant", "templates");
-var SIDE_ROLES = ["research", "debug"];
-function shellQuote2(p) {
-  return "'" + p.replace(/'/g, "'\\''") + "'";
-}
-function titleFor2(project, name) {
-  return `\u{1F5D2} ${project}:${name}`;
-}
-function isSideTitle(project, title) {
-  return title.startsWith(`\u{1F5D2} ${project}:`);
-}
-function nameFromTitle2(project, title) {
-  return title.slice(`\u{1F5D2} ${project}:`.length);
-}
-function nextAutoName2(existingTitles, project) {
-  const used = /* @__PURE__ */ new Set();
-  for (const title of existingTitles) {
-    const n = nameFromTitle2(project, title).match(/^side-(\d+)$/);
-    if (n) used.add(Number(n[1]));
-  }
-  let i = 1;
-  while (used.has(i)) i++;
-  return `side-${i}`;
-}
-function buildSideFirstTurn(topic, project, role, spokeVault, scratchWorktree) {
-  const lines = [
-    topic,
-    "",
-    "---",
-    "Side-session context (for handoff use):",
-    `Project: ${project}`,
-    `Role: ${role}`,
-    `Spoke vault: ${spokeVault}`
-  ];
-  if (scratchWorktree) {
-    lines.push(`Scratch worktree: ${scratchWorktree}`);
-  }
-  return lines.join("\n");
-}
-async function runSideSpawn(input) {
+async function runSideSpawn2(input) {
   const config = loadConfig();
   const proj = config.projects[input.project];
   if (!proj) {
     throw new Error(`Project '${input.project}' not found. Run 'squadrant projects list'.`);
   }
-  if (!SIDE_ROLES.includes(input.role)) {
-    throw new Error(
-      `Unknown side role '${input.role}'. Valid roles: ${SIDE_ROLES.join(", ")}.`
-    );
-  }
   const runtime = new RuntimeRegistry({ cmux: createCmuxDriver() }).forProject(
     input.project,
     config
   );
-  const captain = await runtime.status(proj.captainName);
-  if (!captain) {
-    throw new Error(
-      `Captain workspace '${proj.captainName}' is not running. Run 'squadrant launch ${input.project}' first.`
-    );
-  }
-  const existing = await runtime.listSurfaces(captain.id);
-  const existingTitles = existing.filter((s) => s.title && isSideTitle(input.project, s.title)).map((s) => s.title);
-  if (input.name) {
-    const wantTitle = titleFor2(input.project, input.name);
-    if (existingTitles.includes(wantTitle)) {
-      throw new Error(
-        `Side session '${input.name}' already exists for ${input.project}.`
-      );
-    }
-  }
-  const name = input.name ?? nextAutoName2(existingTitles, input.project);
-  const spawnCwd = input.role === "debug" ? addWorktree({
-    repoRoot: proj.path,
-    worktreeDir: config.defaults.worktreeDir ?? ".worktrees",
-    project: input.project,
-    name,
-    base: resolveWorktreeBase(proj.path)
-  }) : proj.path;
   const agents = new CapabilityRegistry({
     claude: createClaudeDriver(),
     codex: createCodexDriver(),
@@ -6843,80 +7342,39 @@ async function runSideSpawn(input) {
   const promptFile = path21.join(
     TEMPLATES_DIR3,
     `side.${input.role}.${agent.templateSuffix}.md`
-  );
-  const direction = input.direction ?? "tab";
-  const title = titleFor2(input.project, name);
-  const pane = await runtime.newPane({ workspaceId: captain.id, direction, title });
-  const cliCommand = agent.buildCommand({
+  );
+  const agentCmdFactory = (spawnCwd) => agent.buildCommand({
     prompt: input.topic,
     workdir: spawnCwd,
     role: "side",
-    promptFile: fs17.existsSync(promptFile) ? promptFile : void 0,
+    promptFile: fs18.existsSync(promptFile) ? promptFile : void 0,
     interactive: true,
     permissionMode: config.defaults.permissions?.crew ?? "auto",
     ...sideModel ? { model: sideModel } : {}
   });
-  await runtime.sendToPane(pane, `cd ${shellQuote2(spawnCwd)} && ${cliCommand}`);
-  const preLaunchScreen = await runtime.readPaneScreen(pane) ?? "";
-  const firstTurn = buildSideFirstTurn(
-    input.topic,
-    input.project,
-    input.role,
-    proj.spokeVault ?? "",
-    input.role === "debug" ? spawnCwd : void 0
-  );
-  await sendFirstTurnWhenReady(runtime, pane, firstTurn, preLaunchScreen);
-  return { ...pane, title };
+  const sendFirstTurn = (pane, firstTurn, preLaunchScreen) => sendFirstTurnWhenReady(runtime, pane, firstTurn, preLaunchScreen);
+  return runSideSpawn(input, config, { runtime, agentCmdFactory, sendFirstTurn });
 }
-async function runSideSend(project, name, message) {
+async function runSideSend2(project, name, message) {
   const { runtime, workspaceId } = await resolveCaptainWorkspace(project);
-  const want = titleFor2(project, name);
-  const surfaces = await runtime.listSurfaces(workspaceId);
-  const pane = surfaces.find((s) => s.title === want) ?? null;
-  if (!pane) {
-    throw new Error(
-      `Side session '${name}' not found for ${project}. Run 'squadrant side list ${project}'.`
-    );
-  }
-  await runtime.sendToPane(pane, message);
+  await runSideSend(runtime, workspaceId, project, name, message);
 }
-async function runSideList(project) {
+async function runSideList2(project) {
   const { runtime, workspaceId } = await resolveCaptainWorkspace(project);
-  const surfaces = await runtime.listSurfaces(workspaceId);
-  return surfaces.filter((s) => s.title && isSideTitle(project, s.title)).map((s) => ({
-    name: nameFromTitle2(project, s.title),
-    surfaceId: s.surfaceId
-  }));
+  return runSideList(runtime, workspaceId, project);
 }
-async function runSideClose(project, name) {
+async function runSideClose2(project, name) {
   const config = loadConfig();
   const proj = config.projects[project];
   const { runtime, workspaceId } = await resolveCaptainWorkspace(project);
-  const want = titleFor2(project, name);
-  const surfaces = await runtime.listSurfaces(workspaceId);
-  const pane = surfaces.find((s) => s.title === want) ?? null;
-  if (!pane) {
-    throw new Error(
-      `Side session '${name}' not found for ${project}. Run 'squadrant side list ${project}'.`
-    );
-  }
-  await runtime.closePane(pane);
-  if (proj) {
-    const wtPath = worktreePath(
-      proj.path,
-      config.defaults.worktreeDir ?? ".worktrees",
-      project,
-      name
-    );
-    if (fs17.existsSync(wtPath)) {
-      try {
-        removeWorktree(proj.path, wtPath);
-      } catch (e) {
-        process.stderr.write(`(worktree remove failed: ${e.message})
-`);
-      }
-    }
-  }
+  await runSideClose(
+    runtime,
+    workspaceId,
+    project,
+    name,
+    proj?.path,
+    config.defaults.worktreeDir ?? ".worktrees"
+  );
 }
 var sideCommand = new Command10("side").description(
   "Spawn and manage side-sessions (research/debug) \u2014 fresh-context tabs off the daemon lifecycle"
@@ -6935,7 +7393,7 @@ sideCommand.command("spawn").description(
         filePath: opts.topicFile,
         label: "topic"
       });
-      const pane = await runSideSpawn({
+      const pane = await runSideSpawn2({
         project,
         topic: resolvedTopic,
         role: opts.role,
@@ -6952,7 +7410,7 @@ sideCommand.command("spawn").description(
 );
 sideCommand.command("list").description("List live side-sessions for a project").argument("<project>", "Project name").action(async (project) => {
   try {
-    const sessions = await runSideList(project);
+    const sessions = await runSideList2(project);
     if (sessions.length === 0) {
       console.log(chalk10.yellow(`No live side-sessions for ${project}.`));
       return;
@@ -6973,7 +7431,7 @@ sideCommand.command("send").description("Send a follow-up message to an existing
         filePath: opts.messageFile,
         label: "message"
       });
-      await runSideSend(project, name, resolvedMessage);
+      await runSideSend2(project, name, resolvedMessage);
       console.log(chalk10.green(`\u2714 Sent to ${project}:${name}`));
     } catch (err) {
       console.error(chalk10.red(err.message));
@@ -6983,7 +7441,7 @@ sideCommand.command("send").description("Send a follow-up message to an existing
 );
 sideCommand.command("close").description("Close a side-session (closes its tab)").argument("<project>", "Project name").argument("<name>", "Session name").action(async (project, name) => {
   try {
-    await runSideClose(project, name);
+    await runSideClose2(project, name);
     console.log(chalk10.green(`\u2714 Closed ${project}:${name}`));
   } catch (err) {
     console.error(chalk10.red(err.message));
@@ -6996,8 +7454,8 @@ init_dist();
 init_dist3();
 import { Command as Command11 } from "commander";
 import { execSync as execSync10 } from "child_process";
-import { homedir as homedir13 } from "os";
-import { join as join19 } from "path";
+import { homedir as homedir14 } from "os";
+import { join as join20 } from "path";
 import chalk12 from "chalk";
 
 // packages/web/dist/read-status.js
@@ -7136,7 +7594,7 @@ function renderDashboard(rows, opts) {
 
 // packages/web/dist/sync-hub.js
 init_dist();
-import fs18 from "fs";
+import fs19 from "fs";
 import path22 from "path";
 function buildMirrorMarkdown(s) {
   const fenced = "```";
@@ -7163,8 +7621,8 @@ function buildMirrorMarkdown(s) {
 function syncHub(deps) {
   if (!deps.config.hubVault)
     return [];
-  const writeFile5 = deps.writeFile ?? ((p, c) => fs18.writeFileSync(p, c));
-  const mkdir5 = deps.mkdir ?? ((p) => fs18.mkdirSync(p, { recursive: true }));
+  const writeFile5 = deps.writeFile ?? ((p, c) => fs19.writeFileSync(p, c));
+  const mkdir5 = deps.mkdir ?? ((p) => fs19.mkdirSync(p, { recursive: true }));
   const projectsDir = path22.join(resolveHome(deps.config.hubVault), "projects");
   mkdir5(projectsDir);
   const out = [];
@@ -7193,10 +7651,10 @@ function mergeSnapshot(daemon, external, now) {
 // packages/web/dist/probes.js
 init_dist();
 init_dist();
-import { join as join18 } from "path";
-import { homedir as homedir12 } from "os";
+import { join as join19 } from "path";
+import { homedir as homedir13 } from "os";
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 var DEFAULT_TIMEOUT_MS = 2e3;
 var AGENT_CLIS = ["claude", "codex", "gemini", "opencode"];
 function withTimeout2(p, ms) {
@@ -7231,7 +7689,7 @@ function vaultProbe(run, dir) {
       return { state: "unknown", detail: "no vault configured" };
     if (!run.pathExists(dir))
       return { state: "gone", detail: "vault directory missing" };
-    if (!run.pathExists(join18(dir, ".obsidian")))
+    if (!run.pathExists(join19(dir, ".obsidian")))
       return { state: "gone", detail: "no .obsidian/ (not a vault)" };
     return { state: "alive" };
   } catch {
@@ -7299,10 +7757,10 @@ async function runExternalProbes(run, timeoutMs = DEFAULT_TIMEOUT_MS) {
   const sessions = probeSessions(run);
   return { cmux: cmux2, agentClis, vaults, config: { parseable, projectPaths, sessions } };
 }
-var SESSIONS_PATH = join18(homedir12(), ".config", "squadrant", "sessions.json");
+var SESSIONS_PATH = join19(homedir13(), ".config", "squadrant", "sessions.json");
 function onPath(cli) {
   const dirs = (process.env.PATH ?? "").split(":").filter(Boolean);
-  return dirs.some((d) => existsSync10(join18(d, cli)));
+  return dirs.some((d) => existsSync10(join19(d, cli)));
 }
 function readSessionsHashes() {
   const raw = JSON.parse(readFileSync10(SESSIONS_PATH, "utf-8"));
@@ -7313,7 +7771,7 @@ function defaultProbeRunners() {
   return {
     probeCmuxBin: () => new Promise((resolve3) => {
       try {
-        execFile2(resolveCmuxBin(), ["--version"], { timeout: 1500 }, (err) => resolve3(!err));
+        execFile3(resolveCmuxBin(), ["--version"], { timeout: 1500 }, (err) => resolve3(!err));
       } catch {
         resolve3(false);
       }
@@ -7972,7 +8430,7 @@ async function startWebServer(opts) {
 
 // packages/cli/src/commands/dashboard.ts
 init_dist();
-var SOCK3 = join19(homedir13(), ".config", "squadrant", "squadrant.sock");
+var SOCK3 = join20(homedir14(), ".config", "squadrant", "squadrant.sock");
 function detectCurrentWorkspace2() {
   const out = execSync10(`"${resolveCmuxBin()}" current-workspace`, { encoding: "utf-8" }).trim();
   const match = out.match(/workspace:\d+/);
@@ -8055,12 +8513,11 @@ dashboardCommand.command("sync-hub").description("Mirror each spoke status.md in
 init_dist();
 init_dist4();
 init_dist3();
-init_dist();
-init_dist3();
+init_dist2();
 init_dist2();
 import { Command as Command12 } from "commander";
 import { execSync as execSync11 } from "child_process";
-import fs19 from "fs";
+import fs20 from "fs";
 import path23 from "path";
 import os12 from "os";
 import chalk13 from "chalk";
@@ -8074,64 +8531,6 @@ function ensureCmuxReady() {
   console.log(chalk13.bold("  Run `squadrant launch` from inside a cmux workspace.\n"));
   process.exit(0);
 }
-async function deliverStartupPrompt(runtime, refId, prompt, opts = {}) {
-  const readyTimeoutMs = opts.readyTimeoutMs ?? 3e4;
-  const settleMs = opts.settleMs ?? 2500;
-  const pollMs = opts.pollMs ?? 1e3;
-  const maxAttempts = opts.maxAttempts ?? 3;
-  const sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
-  const read = async () => runtime.readScreen(refId).catch(() => "");
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const deadline = Date.now() + readyTimeoutMs;
-    let preSend = await read();
-    let state = classifyStartupSurface(preSend);
-    while (state === "loading" && Date.now() < deadline) {
-      await sleep2(pollMs);
-      preSend = await read();
-      state = classifyStartupSurface(preSend);
-    }
-    if (state === "working") return;
-    await runtime.send(refId, prompt).catch(() => {
-    });
-    if (state === "loading") return;
-    await sleep2(settleMs);
-    const after = await read();
-    if (after !== preSend) return;
-  }
-}
-async function launchWorkspace(runtime, name, agentCmd, cwd, navigate = false, forceFresh = false, pinToTop = false, initialPrompt) {
-  ensureCmuxReady();
-  const existing = await runtime.status(name);
-  if (existing && forceFresh) {
-    console.log(chalk13.yellow(`  Closing stale workspace '${name}' for fresh start`));
-    await runtime.stop(existing.id);
-  } else if (existing) {
-    console.log(chalk13.yellow(`  Workspace '${name}' already exists \u2014 switching to it`));
-    cmuxLocal(["select-workspace", "--workspace", existing.id]);
-    return;
-  }
-  let currentRef;
-  try {
-    const cur = cmuxLocal(["current-workspace"]);
-    currentRef = cur.match(/workspace:\d+/)?.[0];
-  } catch {
-  }
-  const ref = await runtime.spawn({
-    name,
-    workdir: cwd ?? process.cwd(),
-    command: agentCmd,
-    pinToTop
-  });
-  if (initialPrompt) {
-    void deliverStartupPrompt(runtime, ref.id, initialPrompt);
-  }
-  if (navigate) {
-    cmuxLocal(["select-workspace", "--workspace", ref.id]);
-  } else if (currentRef) {
-    cmuxLocal(["select-workspace", "--workspace", currentRef]);
-  }
-  console.log(chalk13.green(`  \u2714 Workspace '${name}' created`));
-}
 var launchCommand = new Command12("launch").description(
   "Launch a project captain (with project arg) or all captains (--all). Use `squadrant command` for one-shot Command tasks."
 ).argument("[project]", "Project name to launch captain for").option("--fresh", "Start a new session instead of resuming the last one").option("--all", "Launch all captain workspaces").action(async (project, opts) => {
@@ -8145,19 +8544,10 @@ var launchCommand = new Command12("launch").description(
   const registry = new CapabilityRegistry(drivers);
   const runtimes = new RuntimeRegistry({ cmux: createCmuxDriver() });
   async function launchOne(workspaceName, role, cwd, permissionMode, navigate, pinToTop = false, projectName) {
-    let forceFresh = !!opts.fresh;
-    if (!forceFresh) {
-      const auto = shouldStartFresh(workspaceName, role, { sessionsPath: SESSIONS_PATH2, templatesDir: TEMPLATES_DIR4 });
-      if (auto.fresh) {
-        console.log(chalk13.cyan(`  \u21BB ${auto.reason}`));
-        forceFresh = true;
-      }
-    }
+    ensureCmuxReady();
     const roleConfig = config.defaults.roles?.[role];
     const agentName = roleConfig?.agent || "claude";
     const model = roleConfig?.model || config.defaults.models?.[role];
-    const agentCmd = buildAgentCmd(agentName, registry, role, forceFresh, permissionMode, model, TEMPLATES_DIR4);
-    recordSession(workspaceName, role, { sessionsPath: SESSIONS_PATH2, templatesDir: TEMPLATES_DIR4 });
     let initialPrompt;
     if (role === "captain") {
       initialPrompt = "Run your startup checklist: use the squadrant:captain-ops skill, complete all startup steps, then report ready.";
@@ -8166,19 +8556,44 @@ var launchCommand = new Command12("launch").description(
     }
     const runtime = projectName ? runtimes.forProject(projectName, config) : runtimes.global(config);
     try {
-      await launchWorkspace(runtime, workspaceName, agentCmd, cwd, navigate, forceFresh, pinToTop, initialPrompt);
+      await launchOneWorkspace({
+        workspaceName,
+        role,
+        cwd,
+        forceFreshOverride: opts.fresh,
+        sessionsPath: SESSIONS_PATH2,
+        templatesDir: TEMPLATES_DIR4,
+        agentCmdFactory: (forceFresh) => buildAgentCmd(agentName, registry, role, forceFresh, permissionMode, model, TEMPLATES_DIR4),
+        initialPrompt,
+        runtime,
+        navigate,
+        pinToTop,
+        classifyScreen: classifyStartupSurface,
+        selectWorkspace: (id) => cmuxLocal(["select-workspace", "--workspace", id]),
+        getCurrentWorkspace: () => {
+          try {
+            return cmuxLocal(["current-workspace"]);
+          } catch {
+            return null;
+          }
+        },
+        onFreshReason: (reason) => console.log(chalk13.cyan(`  \u21BB ${reason}`)),
+        onStoppingStale: (name) => console.log(chalk13.yellow(`  Closing stale workspace '${name}' for fresh start`)),
+        onAlreadyExists: (name) => console.log(chalk13.yellow(`  Workspace '${name}' already exists \u2014 switching to it`)),
+        onCreated: (name) => console.log(chalk13.green(`  \u2714 Workspace '${name}' created`))
+      });
     } catch (err) {
       console.error(chalk13.red(`  \u2718 Failed: ${err.message}`));
     }
   }
   if (opts.all) {
     const hubPath = resolveHome(config.hubVault);
-    fs19.mkdirSync(hubPath, { recursive: true });
+    fs20.mkdirSync(hubPath, { recursive: true });
     console.log(chalk13.bold("\nLaunching all captain workspaces\n"));
     for (const [name, proj] of Object.entries(config.projects)) {
       const projPath = resolveHome(proj.path);
       const spokePath = resolveHome(proj.spokeVault);
-      if (!fs19.existsSync(spokePath)) {
+      if (!fs20.existsSync(spokePath)) {
         const spokeDriver = new WorkspaceRegistry({ obsidian: createObsidianDriver }).forProject(name, config);
         await ensureSpokeLayout(spokeDriver);
         console.log(chalk13.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
@@ -8209,7 +8624,7 @@ var launchCommand = new Command12("launch").description(
     const proj = config.projects[project];
     const projPath = resolveHome(proj.path);
     const spokePath = resolveHome(proj.spokeVault);
-    if (!fs19.existsSync(spokePath)) {
+    if (!fs20.existsSync(spokePath)) {
       const spokeDriver = new WorkspaceRegistry({ obsidian: createObsidianDriver }).forProject(project, config);
       await ensureSpokeLayout(spokeDriver);
       console.log(chalk13.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
@@ -8344,7 +8759,7 @@ Shutting down captain workspace for '${project}'...
 // packages/cli/src/commands/feedback.ts
 init_dist();
 import { Command as Command14 } from "commander";
-import fs20 from "fs";
+import fs21 from "fs";
 import os13 from "os";
 import path24 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -8354,14 +8769,14 @@ var REPO_URL = "https://github.com/tu11aa/squadrant";
 function readPkgVersion() {
   try {
     const pkgPath = path24.join(path24.dirname(fileURLToPath3(import.meta.url)), "..", "package.json");
-    return JSON.parse(fs20.readFileSync(pkgPath, "utf-8")).version ?? "unknown";
+    return JSON.parse(fs21.readFileSync(pkgPath, "utf-8")).version ?? "unknown";
   } catch {
     return "unknown";
   }
 }
 function readMetrics(metricsPath) {
   try {
-    return JSON.parse(fs20.readFileSync(metricsPath, "utf-8"));
+    return JSON.parse(fs21.readFileSync(metricsPath, "utf-8"));
   } catch {
     return {};
   }
@@ -8421,7 +8836,7 @@ init_dist();
 init_dist();
 init_dist3();
 import { Command as Command15 } from "commander";
-import fs21 from "fs";
+import fs22 from "fs";
 import path25 from "path";
 import chalk16 from "chalk";
 import matter3 from "gray-matter";
@@ -8433,9 +8848,9 @@ async function getProjectStandup(name, project, dateStr, registry, config) {
   const spokeVault = resolveHome(project.spokeVault);
   const statusFile = path25.join(spokeVault, "status.md");
   let status = {};
-  if (fs21.existsSync(statusFile)) {
+  if (fs22.existsSync(statusFile)) {
     try {
-      status = matter3(fs21.readFileSync(statusFile, "utf-8")).data;
+      status = matter3(fs22.readFileSync(statusFile, "utf-8")).data;
     } catch {
     }
   }
@@ -8553,15 +8968,15 @@ init_dist();
 init_dist();
 init_dist3();
 import { Command as Command16 } from "commander";
-import fs22 from "fs";
+import fs23 from "fs";
 import path26 from "path";
 import chalk17 from "chalk";
 import matter4 from "gray-matter";
 function readStatus(spokeVault) {
   const statusFile = path26.join(spokeVault, "status.md");
-  if (!fs22.existsSync(statusFile)) return {};
+  if (!fs23.existsSync(statusFile)) return {};
   try {
-    return matter4(fs22.readFileSync(statusFile, "utf-8")).data;
+    return matter4(fs23.readFileSync(statusFile, "utf-8")).data;
   } catch {
     return {};
   }
@@ -8981,7 +9396,7 @@ init_dist3();
 init_dist();
 import { Command as Command20 } from "commander";
 import chalk21 from "chalk";
-import fs23 from "fs";
+import fs24 from "fs";
 import path27 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function parseScope(v) {
@@ -8993,7 +9408,7 @@ function parseScope(v) {
 function findPackageRoot3() {
   let dir = path27.dirname(fileURLToPath4(import.meta.url));
   while (dir !== "/" && dir !== "") {
-    if (fs23.existsSync(path27.join(dir, "package.json"))) return dir;
+    if (fs24.existsSync(path27.join(dir, "package.json"))) return dir;
     dir = path27.dirname(dir);
   }
   return process.cwd();
@@ -9187,13 +9602,14 @@ ${transcript.join("\n")}`
 init_dist();
 init_dist();
 init_dist();
+init_dist2();
 import { Command as Command22 } from "commander";
-import fs24 from "fs";
+import fs25 from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname5, join as join20 } from "path";
+import { dirname as dirname5, join as join21 } from "path";
 import chalk22 from "chalk";
 function runConfigCheck(opts) {
-  const raw = JSON.parse(fs24.readFileSync(opts.configPath, "utf-8"));
+  const raw = JSON.parse(fs25.readFileSync(opts.configPath, "utf-8"));
   const def = getDefaultConfig();
   const items = detectDrift(raw, def);
   let working = raw;
@@ -9210,7 +9626,7 @@ function runConfigCheck(opts) {
     stamped = true;
   }
   if (opts.fix || opts.accept || stamped) {
-    fs24.writeFileSync(opts.configPath, JSON.stringify(working, null, 2) + "\n");
+    fs25.writeFileSync(opts.configPath, JSON.stringify(working, null, 2) + "\n");
   }
   return { items, applied, remaining, stamped };
 }
@@ -9281,7 +9697,7 @@ function printItems(items) {
 var configCommand = new Command22("config").description("Inspect and reconcile squadrant config");
 configCommand.command("check").description("Detect config drift vs the current default schema").option("--fix", "Apply the safe tier (add missing, remove deprecated)", false).option("--accept", "Stamp the current version without changing config (dismiss advisories)", false).option("--json", "Output drift items as JSON", false).action((opts) => {
   const pkgVersion = readPkgVersion2();
-  if (!fs24.existsSync(DEFAULT_CONFIG_PATH)) {
+  if (!fs25.existsSync(DEFAULT_CONFIG_PATH)) {
     console.log(chalk22.yellow("No config found \u2014 run `squadrant init` first."));
     return;
   }
@@ -9326,14 +9742,15 @@ configCommand.command("set").description("Write a config value by dotted key (e.
   }
 });
 function readPkgVersion2() {
-  const pkgPath = join20(dirname5(fileURLToPath5(import.meta.url)), "..", "package.json");
-  return JSON.parse(fs24.readFileSync(pkgPath, "utf-8")).version;
+  const pkgPath = join21(dirname5(fileURLToPath5(import.meta.url)), "..", "package.json");
+  return JSON.parse(fs25.readFileSync(pkgPath, "utf-8")).version;
 }
 
 // packages/cli/src/commands/heal.ts
 import { Command as Command23 } from "commander";
 import chalk23 from "chalk";
 init_dist2();
+init_dist2();
 function buildHealStatus(components) {
   if (components === null) {
     return { healthy: false, daemonUnreachable: true, components: [] };
@@ -9424,90 +9841,10 @@ var healCommand = new Command23("heal").description("Targeted, idempotent remedi
 // packages/cli/src/commands/group.ts
 init_dist();
 init_dist2();
+init_dist2();
 import { Command as Command24 } from "commander";
 import { execSync as execSync13 } from "child_process";
-import { randomUUID as randomUUID4 } from "crypto";
-import { homedir as homedir14 } from "os";
-import { join as join21 } from "path";
 import chalk24 from "chalk";
-var SOCK4 = join21(homedir14(), ".config", "squadrant", "squadrant.sock");
-var WARMUP_TIMEOUT_MS = 12e4;
-var WARMUP_POLL_MS = 1e3;
-function resolveCurrentProject(config) {
-  const cwd = process.cwd();
-  for (const [name, proj] of Object.entries(config.projects)) {
-    const resolvedPath = resolveHome(proj.path);
-    if (cwd.startsWith(resolvedPath)) return name;
-  }
-  return null;
-}
-async function isCaptainAlive(project) {
-  try {
-    const health = await sendRequest(SOCK4, { kind: "health", project }, 5e3);
-    const captain = health?.find((h) => h.kind === "captain" && h.project === project);
-    return captain != null && captain.state !== "gone" && captain.state !== "unknown";
-  } catch {
-    return false;
-  }
-}
-async function waitForWarmup(project, timeoutMs = WARMUP_TIMEOUT_MS, pollMs = WARMUP_POLL_MS) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await isCaptainAlive(project)) return true;
-    await new Promise((r) => setTimeout(r, pollMs));
-  }
-  return false;
-}
-async function runGroupDispatch(opts) {
-  const config = loadConfig();
-  const fromCfg = config.projects[opts.fromProject];
-  const toCfg = config.projects[opts.toProject];
-  if (!toCfg) {
-    throw new Error(`target project '${opts.toProject}' not found in config`);
-  }
-  if (!fromCfg.group || !toCfg.group || fromCfg.group !== toCfg.group) {
-    throw new Error(
-      `cannot dispatch: '${opts.toProject}' (group: ${toCfg.group ?? "none"}) is not in the same group as '${opts.fromProject}' (group: ${fromCfg.group ?? "none"})`
-    );
-  }
-  if (toCfg.acceptDelegations === false) {
-    throw new Error(
-      `cannot dispatch to '${opts.toProject}': project has acceptDelegations set to false`
-    );
-  }
-  const alive = await isCaptainAlive(opts.toProject);
-  if (!alive) {
-    try {
-      execSync13(`squadrant launch ${opts.toProject}`, { stdio: "ignore", timeout: 15e3 });
-    } catch {
-      throw new Error(`failed to launch captain for '${opts.toProject}' \u2014 is squadrant installed?`);
-    }
-    const warmed = await waitForWarmup(opts.toProject, opts.warmupTimeoutMs, opts.warmupPollMs);
-    if (!warmed) {
-      throw new Error(
-        `dispatch to '${opts.toProject}' timed out waiting for captain warmup (>${(opts.warmupTimeoutMs ?? WARMUP_TIMEOUT_MS) / 1e3}s)`
-      );
-    }
-  }
-  const now = Date.now();
-  const attemptId = randomUUID4();
-  const record = {
-    id: randomUUID4(),
-    project: opts.toProject,
-    originProject: opts.fromProject,
-    provider: opts.provider ?? "claude",
-    mode: opts.mode ?? "headless",
-    state: "submitted",
-    task: opts.task,
-    createdAt: now,
-    lastHeartbeat: now,
-    lastEvent: "dispatch",
-    heartbeatBudgetMs: 3e5,
-    attempts: [{ attemptId, startedAt: now, lastHeartbeatAt: now }]
-  };
-  const result = await sendRequest(SOCK4, { kind: "dispatch", record });
-  return result;
-}
 var groupCommand = new Command24("group").description("Cross-project intra-group operations (Phase 1: dispatch)").addCommand(
   new Command24("dispatch").description("Dispatch a task to a sibling project in the same group").argument("<to-project>", "Target project name (must be in the same group)").argument("<task>", "Task description to dispatch").option("--provider <p>", "claude|opencode|codex", "claude").option("--mode <m>", "headless|interactive", "headless").option("--warmup-timeout <s>", "seconds to wait for target captain relay to boot (default: 120)", (v) => parseInt(v, 10) * 1e3).action(async (toProject, task, opts) => {
     const fromProject = resolveCurrentProject(loadConfig());
@@ -9516,13 +9853,20 @@ var groupCommand = new Command24("group").description("Cross-project intra-group
       process.exit(1);
     }
     try {
-      const result = await runGroupDispatch({
+      const result = await dispatchToSibling({
         fromProject,
         toProject,
         task,
         provider: opts.provider,
         mode: opts.mode,
-        warmupTimeoutMs: opts.warmupTimeout
+        warmupTimeoutMs: opts.warmupTimeout,
+        bootCaptain: async (project) => {
+          try {
+            execSync13(`squadrant launch ${project}`, { stdio: "ignore", timeout: 15e3 });
+          } catch {
+            throw new Error(`failed to launch captain for '${project}' \u2014 is squadrant installed?`);
+          }
+        }
       });
       console.log(chalk24.green(`\u2714 Dispatched to '${toProject}' (task ${result.id.slice(0, 8)})`));
       console.log(chalk24.dim(`  originProject: ${result.originProject ?? "none"}`));
@@ -9592,7 +9936,7 @@ var cmuxCommand = new Command25("cmux").description("cmux integration helpers").
 
 // packages/cli/src/commands/effort.ts
 init_dist();
-import fs25 from "fs";
+import fs26 from "fs";
 import path28 from "path";
 import { Command as Command26 } from "commander";
 import chalk26 from "chalk";
@@ -9620,7 +9964,7 @@ function runEffortSet(value, configPath = DEFAULT_CONFIG_PATH) {
 }
 function canonical(p) {
   try {
-    return fs25.realpathSync(p);
+    return fs26.realpathSync(p);
   } catch {
     return path28.resolve(p);
   }
@@ -9676,59 +10020,6 @@ import chalk27 from "chalk";
 function defaultStateRoot() {
   return join22(dirname6(DEFAULT_CONFIG_PATH), "state");
 }
-function runTelegramStatus(opts) {
-  const tg = opts.config.telegram;
-  const env = opts.env ?? process.env;
-  const tokenSet = !!(tg?.botToken ?? env.TELEGRAM_BOT_TOKEN);
-  const links = Object.entries(loadState(opts.stateRoot).topics).map(([key, topicId]) => {
-    const sep2 = key.indexOf("::");
-    return { project: key.slice(0, sep2), scope: key.slice(sep2 + 2), topicId };
-  });
-  return { tokenSet, supergroupId: tg?.supergroupId ?? null, links };
-}
-async function runTelegramSend(opts) {
-  const topicId = loadState(opts.stateRoot).topics[topicKey(opts.project)];
-  if (topicId === void 0) {
-    throw new Error(`project "${opts.project}" is not linked \u2014 run: squadrant telegram link ${opts.project}`);
-  }
-  await opts.client.sendMessage(opts.cfg.supergroupId, topicId, opts.message);
-  return { chatId: opts.cfg.supergroupId, topicId };
-}
-function runTelegramNotifySet(opts) {
-  setNotify(opts.stateRoot, opts.project, opts.active);
-}
-function runTelegramNotifyPref(args) {
-  const { project, dimension, value, root } = args;
-  if (dimension === "crew") {
-    if (!["all", "alert_only", "done_only", "none"].includes(value))
-      return { ok: false, message: "crew must be all|alert_only|done_only|none" };
-    saveProjectOverride(project, { telegram: { notify: { crew: value } } }, root);
-    return { ok: true };
-  }
-  if (value !== "on" && value !== "off") return { ok: false, message: "cap must be on|off" };
-  saveProjectOverride(project, { telegram: { notify: { cap: value === "on" } } }, root);
-  return { ok: true };
-}
-function capAllowed(project, globalNotify, root) {
-  return resolveNotify(globalNotify, loadProjectOverride(project, root)).cap;
-}
-function runTelegramNotifyStatus(opts) {
-  const s = loadState(opts.stateRoot);
-  const projects = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(s.topics)) {
-    const sep2 = key.indexOf("::");
-    projects.add(sep2 === -1 ? key : key.slice(0, sep2));
-  }
-  for (const p of Object.keys(s.notify)) projects.add(p);
-  return [...projects].map((project) => ({ project, active: s.notify[project] === true }));
-}
-async function runTelegramLink(opts) {
-  const existing = loadState(opts.stateRoot).topics[topicKey(opts.project)];
-  if (existing !== void 0) return { topicId: existing, created: false };
-  const topicId = await opts.client.createForumTopic(opts.cfg.supergroupId, topicName(opts.project));
-  setTopic(opts.stateRoot, opts.project, topicId);
-  return { topicId, created: true };
-}
 async function questionMasked() {
   return new Promise((resolve3) => {
     emitKeypressEvents(process.stdin);
@@ -9772,44 +10063,6 @@ async function questionYesNo(prompt) {
     });
   });
 }
-function confirmationText(project, before, after, dim) {
-  if (dim === "active") return `\u{1F515} ${project} \u2014 all notifications muted here. Unmute: squadrant telegram notify ${project} on`;
-  if (dim === "cap") return `\u{1F515} ${project} \u2014 captain messages muted here. Re-enable: squadrant telegram notify ${project} cap on`;
-  return `\u{1F515} ${project} \u2014 crew notifications now '${after.crew}' (was '${before.crew}'). Re-enable: squadrant telegram notify ${project} crew ${before.crew}`;
-}
-async function runNotifyConfirmation(opts) {
-  const { quieter, dim } = isQuieter(opts.before, opts.after);
-  if (!quieter || dim === null) return false;
-  const topicId = loadState(opts.stateRoot).topics[topicKey(opts.project)];
-  if (topicId === void 0) return false;
-  const text = confirmationText(opts.project, opts.before, opts.after, dim);
-  try {
-    await opts.client.sendMessage(opts.cfg.supergroupId, topicId, text);
-    return true;
-  } catch {
-    console.warn(`[squadrant] mute-confirmation send failed for ${opts.project} \u2014 notification preference was still saved`);
-    return false;
-  }
-}
-function resolveSetupToken(existingToken, opts) {
-  if (opts.resetToken || !existingToken) return "prompt";
-  return "try-reuse";
-}
-function resolveSetupUserId(flagUserId, detectedUserId, stateRoot) {
-  return flagUserId ?? detectedUserId ?? loadState(stateRoot).lastUserId;
-}
-async function runRegisterCommands(opts) {
-  await opts.client.setMyCommands(BOT_COMMANDS);
-}
-function runTelegramPostSetup(opts) {
-  const doRestart = opts.doRestart ?? restartDaemonIfRunning;
-  const outcome = doRestart({ reason: "telegram config" });
-  if (outcome === "skipped-not-running") {
-    console.log(chalk27.dim("(daemon not running \u2014 change applies on next start)"));
-  } else if (outcome === "skipped-opt-out") {
-    console.log(chalk27.dim("(run 'squadrant heal daemon' to apply)"));
-  }
-}
 var telegramCommand = new Command27("telegram").description("Two-way Telegram integration: push crew events to a topic and reply into the captain pane");
 telegramCommand.command("status").description("Show Telegram config and linked projects").action(() => {
   const { tokenSet, supergroupId, links } = runTelegramStatus({ config: loadConfig(), stateRoot: defaultStateRoot() });