squadrant 0.12.0 → 0.13.0

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"]);
@@ -2632,7 +2632,8 @@ async function runCrewSend(project, name, message, runtime, workspaceId, deps) {
     }
   } catch {
   }
-  await runtime.sendToPane(crew, message);
+  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);
@@ -2699,6 +2700,12 @@ var init_crew_spawn = __esm({
   }
 });
 
+// packages/core/dist/lifecycle-source.js
+var init_lifecycle_source = __esm({
+  "packages/core/dist/lifecycle-source.js"() {
+  }
+});
+
 // packages/core/dist/index.js
 var init_dist2 = __esm({
   "packages/core/dist/index.js"() {
@@ -2731,6 +2738,7 @@ var init_dist2 = __esm({
     init_launch_workspace();
     init_side_session();
     init_crew_spawn();
+    init_lifecycle_source();
   }
 });
 
@@ -2999,8 +3007,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 {
@@ -3554,8 +3568,357 @@ var init_daemon_cmux = __esm({
   }
 });
 
+// packages/workspaces/dist/cmux-daemon/cmux-store-source.js
+import { join as join13 } from "path";
+import { homedir as homedir8 } from "os";
+import { watch, readdirSync as readdirSync3, readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+function parseLifecycleState(s) {
+  if (s === "running" || s === "idle" || s === "needsInput" || s === "unknown") {
+    return s;
+  }
+  return "unknown";
+}
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function defaultListFiles(dir) {
+  try {
+    return readdirSync3(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
+  } catch {
+    return [];
+  }
+}
+function defaultReadFile(path29) {
+  try {
+    return readFileSync8(path29, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function defaultWatchDir(dir, cb) {
+  const w = watch(dir, (_event, filename) => {
+    if (typeof filename === "string" && filename.endsWith("-hook-sessions.json")) {
+      cb();
+    }
+  });
+  return () => w.close();
+}
+var CmuxStoreSource;
+var init_cmux_store_source = __esm({
+  "packages/workspaces/dist/cmux-daemon/cmux-store-source.js"() {
+    CmuxStoreSource = class {
+      name = "cmux-store";
+      stateDir;
+      debounceMs;
+      isPidAlive;
+      listFiles;
+      readFile;
+      fileExists;
+      watchDir;
+      scheduleTimer;
+      cancelTimer;
+      log;
+      deps;
+      stopWatcher;
+      debounceTimer;
+      /** taskId → last reported snapshot (for snapshot() liveness floor). */
+      cache = /* @__PURE__ */ new Map();
+      constructor(opts = {}) {
+        this.stateDir = opts.stateDir ?? process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join13(homedir8(), ".cmuxterm");
+        this.debounceMs = opts.debounceMs ?? 50;
+        this.isPidAlive = opts.isPidAlive ?? defaultIsPidAlive;
+        this.listFiles = opts.listFiles ?? defaultListFiles;
+        this.readFile = opts.readFile ?? defaultReadFile;
+        this.fileExists = opts.fileExists ?? existsSync10;
+        this.watchDir = opts.watchDir ?? defaultWatchDir;
+        this.scheduleTimer = opts.scheduleTimer ?? setTimeout;
+        this.cancelTimer = opts.cancelTimer ?? clearTimeout;
+        this.log = opts.log ?? (() => {
+        });
+      }
+      start(deps) {
+        this.deps = deps;
+        this.scan();
+        try {
+          this.stopWatcher = this.watchDir(this.stateDir, () => this.scheduleDebounced());
+        } catch (e) {
+          this.log(`cmux-store: failed to watch ${this.stateDir}: ${e.message}`);
+        }
+      }
+      stop() {
+        if (this.debounceTimer !== void 0) {
+          this.cancelTimer(this.debounceTimer);
+          this.debounceTimer = void 0;
+        }
+        this.stopWatcher?.();
+        this.stopWatcher = void 0;
+        this.deps = void 0;
+        this.cache.clear();
+      }
+      /** Returns the last-reported snapshot for a known crew (liveness floor). */
+      snapshot(taskId) {
+        return this.cache.get(taskId);
+      }
+      // ── private ─────────────────────────────────────────────────────────────────
+      scheduleDebounced() {
+        if (this.debounceTimer !== void 0) {
+          this.cancelTimer(this.debounceTimer);
+        }
+        this.debounceTimer = this.scheduleTimer(() => {
+          this.debounceTimer = void 0;
+          this.scan();
+        }, this.debounceMs);
+      }
+      scan() {
+        if (!this.deps)
+          return;
+        for (const filename of this.listFiles(this.stateDir)) {
+          this.scanFile(filename);
+        }
+      }
+      scanFile(filename) {
+        const deps = this.deps;
+        const filePath = join13(this.stateDir, filename);
+        const lockPath = `${filePath}.lock`;
+        if (this.fileExists(lockPath)) {
+          this.log(`cmux-store: skipping ${filename} (locked)`);
+          return;
+        }
+        const raw = this.readFile(filePath);
+        if (!raw)
+          return;
+        let parsed;
+        try {
+          parsed = JSON.parse(raw);
+        } catch {
+          this.log(`cmux-store: failed to parse ${filename}`);
+          return;
+        }
+        for (const session of Object.values(parsed.sessions ?? {})) {
+          this.processSession(session, deps);
+        }
+      }
+      processSession(session, deps) {
+        if (!session.sessionId || !session.cwd || typeof session.pid !== "number")
+          return;
+        const hint = {
+          cwd: session.cwd,
+          pid: session.pid,
+          sessionId: session.sessionId
+        };
+        const resolved = deps.resolve(hint);
+        if (!resolved)
+          return;
+        let alive = this.isPidAlive(session.pid);
+        if (!alive && session.isRestorable === true && session.agentLifecycle === "idle") {
+          alive = true;
+        }
+        const snap = {
+          taskId: resolved.id,
+          state: parseLifecycleState(session.agentLifecycle),
+          alive,
+          // "agent": the store carries the agent's own reported lifecycle state,
+          // not a scan inference. needsInput from the store is authoritative.
+          origin: "agent",
+          at: Math.floor((session.updatedAt ?? 0) * 1e3),
+          pid: session.pid,
+          ...session.lastBody ? { detail: { note: session.lastBody } } : {}
+        };
+        this.cache.set(resolved.id, snap);
+        deps.report(snap);
+      }
+    };
+  }
+});
+
+// packages/workspaces/dist/native-hooks/native-hook-source.js
+import { join as join14 } from "path";
+import { homedir as homedir9 } from "os";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+function installClaudeHooks(opts = {}) {
+  const settingsPath = opts.settingsPath ?? join14(homedir9(), ".claude", "settings.json");
+  const hookCmd = opts.hookCmd ?? DEFAULT_HOOK_CMD;
+  const readFile6 = opts.readFile ?? defaultReadFile2;
+  const writeFile5 = opts.writeFile ?? defaultWriteFile;
+  const log = opts.log ?? (() => {
+  });
+  let settings = {};
+  const raw = readFile6(settingsPath);
+  if (raw) {
+    try {
+      settings = JSON.parse(raw);
+    } catch {
+      log(`native-hook: failed to parse ${settingsPath} \u2014 hooks section will be reset`);
+    }
+  }
+  if (typeof settings.hooks !== "object" || settings.hooks === null || Array.isArray(settings.hooks)) {
+    settings.hooks = {};
+  }
+  const hooks = settings.hooks;
+  let changed = false;
+  for (const [eventName, sub, matcher] of CLAUDE_HOOK_EVENTS) {
+    if (!Array.isArray(hooks[eventName])) {
+      hooks[eventName] = [];
+    }
+    const entries = hooks[eventName];
+    const command = `${hookCmd} claude ${sub}`;
+    const hookMatcher = matcher ?? "";
+    const alreadyPresent = entries.some((m) => Array.isArray(m.hooks) && m.hooks.some((h) => typeof h.command === "string" && h.command === command));
+    if (!alreadyPresent) {
+      entries.push({ matcher: hookMatcher, hooks: [{ type: "command", command, timeout: 10 }] });
+      changed = true;
+    }
+  }
+  if (changed) {
+    writeFile5(settingsPath, JSON.stringify(settings, null, 2));
+  }
+  return settingsPath;
+}
+function mapSubToLifecycle(sub) {
+  switch (sub) {
+    case "session-start":
+      return "running";
+    case "prompt-submit":
+      return "running";
+    case "pre-tool-use":
+      return "running";
+    case "stop":
+      return "idle";
+    case "notification":
+      return "needsInput";
+    case "ask-question":
+      return "needsInput";
+    case "session-end":
+      return "session-end";
+    default:
+      return null;
+  }
+}
+function extractDetail(sub, payload) {
+  if (!payload || typeof payload !== "object")
+    return void 0;
+  const p = payload;
+  if (sub === "notification") {
+    const note = typeof p.message === "string" ? p.message : void 0;
+    return note ? { note } : void 0;
+  }
+  if (sub === "pre-tool-use") {
+    const tool = typeof p.tool_name === "string" ? p.tool_name : void 0;
+    return tool ? { tool } : void 0;
+  }
+  return void 0;
+}
+function defaultReadFile2(path29) {
+  try {
+    return readFileSync9(path29, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function defaultWriteFile(path29, content) {
+  mkdirSync6(path29.replace(/\/[^/]+$/, ""), { recursive: true });
+  writeFileSync7(path29, content, "utf-8");
+}
+var CLAUDE_HOOK_EVENTS, DEFAULT_HOOK_CMD, NativeHookSource;
+var init_native_hook_source = __esm({
+  "packages/workspaces/dist/native-hooks/native-hook-source.js"() {
+    CLAUDE_HOOK_EVENTS = [
+      ["SessionStart", "session-start"],
+      ["UserPromptSubmit", "prompt-submit"],
+      ["PreToolUse", "pre-tool-use"],
+      ["Stop", "stop"],
+      ["Notification", "notification"],
+      ["PreToolUse", "ask-question", "AskUserQuestion"],
+      ["SessionEnd", "session-end"]
+    ];
+    DEFAULT_HOOK_CMD = "squadrant hooks";
+    NativeHookSource = class {
+      name = "native-hook";
+      hookInstall;
+      log;
+      deps;
+      /** taskId → last-reported snapshot, for snapshot() liveness floor. */
+      cache = /* @__PURE__ */ new Map();
+      constructor(opts = {}) {
+        this.hookInstall = opts.hookInstall ?? {};
+        this.log = opts.log ?? (() => {
+        });
+      }
+      start(deps) {
+        this.deps = deps;
+      }
+      stop() {
+        this.deps = void 0;
+        this.cache.clear();
+      }
+      /** Returns the last-reported snapshot for a known crew (liveness floor poll). */
+      snapshot(taskId) {
+        return this.cache.get(taskId);
+      }
+      /**
+       * Install squadrant-owned hooks into ~/.claude/settings.json.
+       * Idempotent — safe to call on every project init or crew spawn.
+       * Returns the path to the settings file.
+       */
+      install() {
+        return installClaudeHooks(this.hookInstall);
+      }
+      /**
+       * Receive a lifecycle hook event from the daemon and report a LifecycleSnapshot.
+       *
+       * The daemon's 'squadrant hooks claude <sub>' CLI subcommand calls this after
+       * reading SQUADRANT_CREW_TASK_ID from the hook's process environment — the only
+       * collision-proof correlation key (blueprint §2.2 priority 1).
+       *
+       * @param sub     Sub-event alias: "session-start" | "prompt-submit" | "stop" | …
+       * @param taskId  SQUADRANT_CREW_TASK_ID extracted from the hook process env.
+       * @param pid     Optional: OS pid from the hook's process env or argv.
+       * @param payload Optional: parsed JSON payload from hook stdin (best-effort detail).
+       */
+      handleHook(sub, taskId, pid, payload) {
+        if (!this.deps)
+          return;
+        const mapped = mapSubToLifecycle(sub);
+        if (mapped === null) {
+          this.log(`native-hook: unknown sub '${sub}' for task ${taskId} \u2014 ignored`);
+          return;
+        }
+        const isSessionEnd = mapped === "session-end";
+        const state = isSessionEnd ? "unknown" : mapped;
+        const detail = extractDetail(sub, payload);
+        const snap = {
+          taskId,
+          state,
+          alive: !isSessionEnd,
+          origin: "agent",
+          at: Date.now(),
+          ...pid !== void 0 ? { pid } : {},
+          ...detail ? { detail } : {}
+        };
+        this.cache.set(taskId, snap);
+        this.deps.report(snap);
+      }
+    };
+  }
+});
+
 // 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();
@@ -3589,6 +3952,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);
@@ -3604,8 +3984,8 @@ async function sendFirstTurnWhenReady(runtime, pane, task, preLaunchScreen, acce
     }
   }
   const preSendScreen = await runtime.readPaneScreen(pane) ?? "";
-  await runtime.sendToPane(pane, task);
   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) ?? "";
@@ -3616,21 +3996,25 @@ async function sendFirstTurnWhenReady(runtime, pane, task, preLaunchScreen, acce
         await runtime.sendToPane(pane, task);
       }
     }
-  } else {
-    const retryLimit = acceptanceConfig?.retryLimit ?? 2;
-    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)) {
-        return;
-      }
-      if (attempt < retryLimit - 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) ?? "";
+    const draft = parseDraftFromScreen(afterScreen);
+    if (draft === "")
+      return;
+    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, SPLASH_MAX_CHECKS, SPLASH_RESEND_EVERY_N;
+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();
@@ -3643,6 +4027,9 @@ var init_crew_pane = __esm({
     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;
   }
 });
 
@@ -3651,20 +4038,25 @@ var dist_exports = {};
 __export(dist_exports, {
   CMUX_TIMEOUT: () => CMUX_TIMEOUT,
   CmuxEventsBridge: () => CmuxEventsBridge,
+  CmuxStoreSource: () => CmuxStoreSource,
   DaemonCmux: () => DaemonCmux,
+  NativeHookSource: () => NativeHookSource,
   NotifierRegistry: () => NotifierRegistry,
   RuntimeRegistry: () => RuntimeRegistry,
   WorkspaceRegistry: () => WorkspaceRegistry,
   classifyStartupSurface: () => classifyStartupSurface,
   cmuxLocal: () => cmuxLocal,
+  confirmedSendToPane: () => confirmedSendToPane,
   createCmuxDriver: () => createCmuxDriver,
   createCmuxNotifier: () => createCmuxNotifier,
   createObsidianDriver: () => createObsidianDriver,
   deriveRunState: () => deriveRunState,
   findCrew: () => findCrew,
   getFreePort: () => getFreePort,
+  installClaudeHooks: () => installClaudeHooks,
   isInsideCmux: () => isInsideCmux,
   listProjectCrews: () => listProjectCrews,
+  mapSubToLifecycle: () => mapSubToLifecycle,
   resolveCaptainWorkspace: () => resolveCaptainWorkspace,
   sendFirstTurnWhenReady: () => sendFirstTurnWhenReady
 });
@@ -3675,6 +4067,8 @@ var init_dist3 = __esm({
     init_workspaces2();
     init_events_bridge();
     init_daemon_cmux();
+    init_cmux_store_source();
+    init_native_hook_source();
     init_crew_pane();
   }
 });
@@ -4604,13 +4998,99 @@ var init_app_server_client = __esm({
   }
 });
 
+// packages/agents/dist/codex/codex-app-server-source.js
+function toSnapshot(ev) {
+  const now = Date.now();
+  switch (ev.type) {
+    // ── running: a turn is live ──────────────────────────────────────────────
+    case "task.started":
+    case "task.reattached":
+    case "task.turn.started":
+    case "task.delta":
+    case "task.progress":
+      return { taskId: ev.id, state: "running", alive: true, origin: "agent", at: now };
+    // ── idle: turn ended, crew alive, awaiting next input ────────────────────
+    // task.failed: the turn ended with an error, but the crew process is alive.
+    // task.session.ended: process is gone (alive:false) — signals liveness loss.
+    case "task.turn.completed":
+      return { taskId: ev.id, state: "idle", alive: true, origin: "agent", at: now };
+    case "task.failed":
+      return { taskId: ev.id, state: "idle", alive: true, origin: "agent", at: now };
+    case "task.session.ended":
+      return { taskId: ev.id, state: "idle", alive: false, origin: "agent", at: now };
+    // ── needsInput: crew is blocked on a human ───────────────────────────────
+    case "task.approval.requested":
+      return {
+        taskId: ev.id,
+        state: "needsInput",
+        alive: true,
+        origin: "agent",
+        at: now,
+        detail: { note: ev.question, reason: ev.kind }
+      };
+    case "task.input.requested":
+      return {
+        taskId: ev.id,
+        state: "needsInput",
+        alive: true,
+        origin: "agent",
+        at: now,
+        detail: { note: ev.question }
+      };
+    // ── terminal / notify-only — ignored ────────────────────────────────────
+    // task.done, task.blocked, task.cancelled: terminal state from crew signal only.
+    // task.session, task.stalled, task.quiet, task.idle, task.timeout, etc.: no-op.
+    default:
+      return null;
+  }
+}
+var CodexAppServerSource;
+var init_codex_app_server_source = __esm({
+  "packages/agents/dist/codex/codex-app-server-source.js"() {
+    CodexAppServerSource = class {
+      name = "codex-appserver";
+      deps;
+      /** taskId → last reported snapshot (for snapshot() liveness floor). */
+      cache = /* @__PURE__ */ new Map();
+      start(deps) {
+        this.deps = deps;
+      }
+      stop() {
+        this.deps = void 0;
+        this.cache.clear();
+      }
+      /** Returns the last-reported snapshot for a known crew (liveness floor). */
+      snapshot(taskId) {
+        return this.cache.get(taskId);
+      }
+      /**
+       * Feed a ControlEvent from CodexInteractiveDriver into this source.
+       * The daemon wires: emit = (ev) => { source.observe(ev); handle(ev); }
+       *
+       * All events that carry lifecycle meaning for a codex crew are mapped to a
+       * LifecycleSnapshot and reported. Events that are terminal signals (task.done,
+       * task.cancelled, task.blocked) or notify-only (task.stalled, task.quiet, etc.)
+       * are ignored — terminal state still comes exclusively from `squadrant crew signal`
+       * (anti-#2576 invariant).
+       */
+      observe(ev) {
+        const snap = toSnapshot(ev);
+        if (!snap || !this.deps)
+          return;
+        this.cache.set(snap.taskId, snap);
+        this.deps.report(snap);
+      }
+    };
+  }
+});
+
 // packages/agents/dist/codex/config.js
 import { readFile as readFile5 } from "fs/promises";
-import { homedir as homedir9 } from "os";
-import { join as join14 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join16 } from "path";
 async function resolveCodexModel() {
-  const home = process.env["CODEX_HOME"] ?? join14(homedir9(), ".codex");
-  const configPath = join14(home, "config.toml");
+  const home = process.env["CODEX_HOME"] ?? join16(homedir11(), ".codex");
+  const configPath = join16(home, "config.toml");
   let text;
   try {
     text = await readFile5(configPath, "utf8");
@@ -5131,9 +5611,9 @@ 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 homedir10 } from "os";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join17 } from "path";
 function probeClaudeSettingsFlag() {
   try {
     const help = execSync7("claude --help", { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
@@ -5184,11 +5664,11 @@ function deriveTranscriptPath(sessionId, cwd) {
   if (!sessionId || !cwd)
     return null;
   const escaped = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-  return join15(homedir10(), ".claude", "projects", escaped, `${sessionId}.jsonl`);
+  return join17(homedir12(), ".claude", "projects", escaped, `${sessionId}.jsonl`);
 }
 function readLastAssistantText(transcriptPath) {
   try {
-    const raw = readFileSync8(transcriptPath, "utf-8");
+    const raw = readFileSync10(transcriptPath, "utf-8");
     const lines = raw.split(/\r?\n/);
     for (let i = lines.length - 1; i >= 0; i--) {
       const line = lines[i].trim();
@@ -5305,6 +5785,18 @@ function classifyPaneTail(tail) {
     }
     return { kind: "approval", text: "Crew is awaiting permission approval." };
   }
+  const hasPickerFooter = cleaned.some((c) => c != null && PICKER_FOOTER_RE.test(c));
+  if (options.length >= 2 && hasPickerFooter) {
+    const firstOptCi = options[0].ci;
+    for (let i = firstOptCi - 1; i >= 0; i--) {
+      const c = cleaned[i];
+      if (c == null)
+        continue;
+      if (c.endsWith("?"))
+        return { kind: "question", text: c };
+    }
+    return { kind: "question", text: "Crew is awaiting a choice." };
+  }
   const region = cleaned.filter((c) => c != null).join("\n");
   const q = detectTrailingQuestion(region);
   if (q)
@@ -5332,7 +5824,7 @@ function stripChrome(raw) {
     return null;
   return trimmed;
 }
-var ERROR_BANNER_RE, OPTION_RE, PURE_CHROME_RE, STATUS_LINE_RE;
+var ERROR_BANNER_RE, OPTION_RE, PICKER_FOOTER_RE, PURE_CHROME_RE, STATUS_LINE_RE;
 var init_pane_classifier = __esm({
   "packages/agents/dist/interactive/pane-classifier.js"() {
     init_claude2();
@@ -5346,6 +5838,7 @@ var init_pane_classifier = __esm({
       /\bmaximum\s+retries\b/i
     ];
     OPTION_RE = /^[❯>›]?\s*(\d+)\.\s+(.*\S)\s*$/;
+    PICKER_FOOTER_RE = /↑↓\s*select|enter\s+submit|esc\s+dismiss/i;
     PURE_CHROME_RE = /^[\s─━│┃╭╮╰╯┌┐└┘├┤┬┴┼═║╔╗╚╝╠╣╦╩╬▁▂▃▄▅▆▇█▔▏▕]+$/;
     STATUS_LINE_RE = /accept edits on|shift\+tab|⏵⏵|\? for shortcuts|esc to interrupt|tokens? (used|left)|context left/i;
   }
@@ -5576,6 +6069,7 @@ var dist_exports2 = {};
 __export(dist_exports2, {
   AppServerClient: () => AppServerClient,
   CapabilityRegistry: () => CapabilityRegistry,
+  CodexAppServerSource: () => CodexAppServerSource,
   CodexInteractiveDriver: () => CodexInteractiveDriver,
   HEADLESS_ERROR_TAIL: () => HEADLESS_ERROR_TAIL,
   MARKER_END: () => MARKER_END,
@@ -5614,6 +6108,7 @@ var init_dist4 = __esm({
     init_drivers();
     init_projection2();
     init_app_server_client();
+    init_codex_app_server_source();
     init_driver();
     init_normalize();
     init_sse_bridge();
@@ -5630,11 +6125,11 @@ var init_dist4 = __esm({
 // packages/cli/src/index.ts
 init_dist();
 init_dist2();
-import { Command as Command28 } from "commander";
-import { readFileSync as readFileSync11, existsSync as existsSync11, writeFileSync as writeFileSync9 } from "fs";
+import { Command as Command29 } from "commander";
+import { readFileSync as readFileSync13, existsSync as existsSync12, writeFileSync as writeFileSync10 } from "fs";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname7, join as join23 } from "path";
-import { homedir as homedir15 } from "os";
+import { dirname as dirname7, join as join26 } from "path";
+import { homedir as homedir18 } from "os";
 
 // packages/cli/src/commands/doctor.ts
 init_dist();
@@ -5651,10 +6146,10 @@ import chalk3 from "chalk";
 // packages/cli/src/commands/health-view.ts
 init_dist2();
 init_dist2();
-import { homedir as homedir8 } from "os";
-import { join as join13 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join15 } from "path";
 import chalk2 from "chalk";
-var SOCK = join13(homedir8(), ".config", "squadrant", "squadrant.sock");
+var SOCK = join15(homedir10(), ".config", "squadrant", "squadrant.sock");
 async function queryHealth(project) {
   try {
     const reply = await sendRequest(SOCK, { kind: "health", project });
@@ -6488,9 +6983,9 @@ init_dist4();
 import { Command as Command8 } from "commander";
 import { createConnection as createConnection3 } from "net";
 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";
+import { homedir as homedir14 } from "os";
+import { join as join19 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
 
 // packages/cli/src/commands/crew-output.ts
 function tailLines(text, maxLines = 40, maxBytes = 4096) {
@@ -6548,11 +7043,11 @@ init_dist2();
 import { Command as Command6 } from "commander";
 import chalk8 from "chalk";
 import { createConnection as createConnection2 } from "net";
-import { homedir as homedir11 } from "os";
-import { join as join16 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join18 } from "path";
 import { createInterface } from "readline";
 function socketPath() {
-  return process.env.SQUADRANTD_SOCK ?? join16(homedir11(), ".config", "squadrant", "squadrant.sock");
+  return process.env.SQUADRANTD_SOCK ?? join18(homedir13(), ".config", "squadrant", "squadrant.sock");
 }
 function rule(width, ch = "\u2500") {
   return ch.repeat(Math.max(0, width));
@@ -6788,7 +7283,7 @@ var crewChatCommand = new Command7("chat").description("[DEPRECATED] alias for `
 });
 
 // packages/cli/src/commands/crew-control.ts
-var SOCK2 = join17(homedir12(), ".config", "squadrant", "squadrant.sock");
+var SOCK2 = join19(homedir14(), ".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));
@@ -6893,10 +7388,10 @@ function buildSignalRequest(signal, o) {
   return { kind: "event", project, event };
 }
 function defaultWriteResult(id, payload) {
-  const dir = join17(homedir12(), ".config", "squadrant", "state", "_results");
-  mkdirSync6(dir, { recursive: true });
-  const file = join17(dir, `${id}.txt`);
-  writeFileSync7(file, payload);
+  const dir = join19(homedir14(), ".config", "squadrant", "state", "_results");
+  mkdirSync7(dir, { recursive: true });
+  const file = join19(dir, `${id}.txt`);
+  writeFileSync8(file, payload);
   return file;
 }
 function addControlPlaneCrewCommands(crew) {
@@ -6995,8 +7490,8 @@ 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 join18 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { join as join20 } from "path";
 var CREW_PERMISSION_ALLOWLIST = [
   // git — read + safe mutations (reset/clean/config intentionally excluded)
   "Bash(git status:*)",
@@ -7087,24 +7582,24 @@ function mergeCrewPermissions(settings) {
   return next;
 }
 function writePerCrewSettingsLocal(o) {
-  const dir = join18(o.projectCwd, ".claude");
-  mkdirSync7(dir, { recursive: true });
-  const file = join18(dir, "settings.local.json");
+  const dir = join20(o.projectCwd, ".claude");
+  mkdirSync8(dir, { recursive: true });
+  const file = join20(dir, "settings.local.json");
   let existing = {};
   try {
-    const raw = healStaleCockpitRefs(readFileSync9(file, "utf-8"));
+    const raw = healStaleCockpitRefs(readFileSync11(file, "utf-8"));
     existing = JSON.parse(raw);
   } catch {
   }
   const withHooks = mergeClaudeHooks(existing, o.hookCmd ?? "squadrant crew _hook");
   const merged = mergeCrewPermissions(withHooks);
-  writeFileSync8(file, JSON.stringify(merged, null, 2));
+  writeFileSync9(file, JSON.stringify(merged, null, 2));
   return file;
 }
 function writePerCrewOpencodeConfig(o) {
-  const dir = join18(o.stateRoot, o.project, o.taskId);
-  mkdirSync7(dir, { recursive: true });
-  const file = join18(dir, "opencode.json");
+  const dir = join20(o.stateRoot, o.project, o.taskId);
+  mkdirSync8(dir, { recursive: true });
+  const file = join20(dir, "opencode.json");
   const config = {
     permission: {
       read: "allow",
@@ -7119,7 +7614,7 @@ function writePerCrewOpencodeConfig(o) {
       external_directory: { "**": "allow" }
     }
   };
-  writeFileSync8(file, JSON.stringify(config, null, 2));
+  writeFileSync9(file, JSON.stringify(config, null, 2));
   return file;
 }
 
@@ -7160,7 +7655,10 @@ async function runCrewSend2(project, name, message) {
     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 runCrewRead2(project, name) {
@@ -7409,8 +7907,8 @@ init_dist();
 init_dist3();
 import { Command as Command11 } from "commander";
 import { execSync as execSync10 } from "child_process";
-import { homedir as homedir14 } from "os";
-import { join as join20 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join22 } from "path";
 import chalk12 from "chalk";
 
 // packages/web/dist/read-status.js
@@ -7606,9 +8104,9 @@ function mergeSnapshot(daemon, external, now) {
 // packages/web/dist/probes.js
 init_dist();
 init_dist();
-import { join as join19 } from "path";
-import { homedir as homedir13 } from "os";
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { join as join21 } from "path";
+import { homedir as homedir15 } from "os";
+import { existsSync as existsSync11, readFileSync as readFileSync12 } from "fs";
 import { execFile as execFile3 } from "child_process";
 var DEFAULT_TIMEOUT_MS = 2e3;
 var AGENT_CLIS = ["claude", "codex", "gemini", "opencode"];
@@ -7644,7 +8142,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(join19(dir, ".obsidian")))
+    if (!run.pathExists(join21(dir, ".obsidian")))
       return { state: "gone", detail: "no .obsidian/ (not a vault)" };
     return { state: "alive" };
   } catch {
@@ -7712,13 +8210,13 @@ async function runExternalProbes(run, timeoutMs = DEFAULT_TIMEOUT_MS) {
   const sessions = probeSessions(run);
   return { cmux: cmux2, agentClis, vaults, config: { parseable, projectPaths, sessions } };
 }
-var SESSIONS_PATH = join19(homedir13(), ".config", "squadrant", "sessions.json");
+var SESSIONS_PATH = join21(homedir15(), ".config", "squadrant", "sessions.json");
 function onPath(cli) {
   const dirs = (process.env.PATH ?? "").split(":").filter(Boolean);
-  return dirs.some((d) => existsSync10(join19(d, cli)));
+  return dirs.some((d) => existsSync11(join21(d, cli)));
 }
 function readSessionsHashes() {
-  const raw = JSON.parse(readFileSync10(SESSIONS_PATH, "utf-8"));
+  const raw = JSON.parse(readFileSync12(SESSIONS_PATH, "utf-8"));
   const hashes = Object.values(raw.workspaces ?? {}).map((w) => w.templateHash).filter((h) => typeof h === "string" && h.length > 0);
   return [...new Set(hashes)];
 }
@@ -7732,7 +8230,7 @@ function defaultProbeRunners() {
       }
     }),
     probeOnPath: async (cli) => onPath(cli),
-    pathExists: (p) => existsSync10(p),
+    pathExists: (p) => existsSync11(p),
     loadConfig: () => loadConfig(),
     loadSessionsHashes: () => readSessionsHashes()
   };
@@ -8385,7 +8883,7 @@ async function startWebServer(opts) {
 
 // packages/cli/src/commands/dashboard.ts
 init_dist();
-var SOCK3 = join20(homedir14(), ".config", "squadrant", "squadrant.sock");
+var SOCK3 = join22(homedir16(), ".config", "squadrant", "squadrant.sock");
 function detectCurrentWorkspace2() {
   const out = execSync10(`"${resolveCmuxBin()}" current-workspace`, { encoding: "utf-8" }).trim();
   const match = out.match(/workspace:\d+/);
@@ -8469,13 +8967,87 @@ init_dist();
 init_dist4();
 init_dist3();
 init_dist2();
-init_dist2();
 import { Command as Command12 } from "commander";
 import { execSync as execSync11 } from "child_process";
 import fs20 from "fs";
 import path23 from "path";
 import os12 from "os";
 import chalk13 from "chalk";
+
+// packages/cli/src/commands/launch-interactive.ts
+import checkbox, { Separator } from "@inquirer/checkbox";
+function getYesterday() {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - 1);
+  return d.toISOString().slice(0, 10);
+}
+function partitionByYesterday(entries, yesterday) {
+  const y = [];
+  const r = [];
+  for (const e of entries) {
+    if (e.lastLaunched === yesterday) {
+      y.push(e);
+    } else {
+      r.push(e);
+    }
+  }
+  return { yesterday: y, rest: r };
+}
+async function selectCaptainsInteractive(entries, yesterday = getYesterday()) {
+  const { yesterday: yesterdayEntries, rest: restEntries } = partitionByYesterday(entries, yesterday);
+  if (yesterdayEntries.length === 0) {
+    const result2 = await checkbox({
+      message: "Select captains to launch:",
+      choices: entries.map((e) => ({
+        name: `${e.captainName} (${e.projectName})`,
+        value: e.projectName,
+        checked: false
+      })),
+      pageSize: 20
+    });
+    return result2;
+  }
+  const initialChoices = [
+    new Separator("\u2500\u2500 Opened yesterday \u2500\u2500"),
+    ...yesterdayEntries.map((e) => ({
+      name: `${e.captainName} (${e.projectName})`,
+      value: e.projectName,
+      checked: true
+    })),
+    new Separator(),
+    { name: "Show all projects", value: "__show_all__", checked: false }
+  ];
+  const result = await checkbox({
+    message: "Select captains to launch:",
+    choices: initialChoices,
+    pageSize: 20
+  });
+  if (result.includes("__show_all__")) {
+    const allChecked = yesterdayEntries.map((e) => e.projectName);
+    const result2 = await checkbox({
+      message: "Select captains to launch (all projects):",
+      choices: [
+        new Separator("\u2500\u2500 Opened yesterday \u2500\u2500"),
+        ...yesterdayEntries.map((e) => ({
+          name: `${e.captainName} (${e.projectName})`,
+          value: e.projectName,
+          checked: allChecked.includes(e.projectName)
+        })),
+        ...restEntries.map((e) => ({
+          name: `${e.captainName} (${e.projectName})`,
+          value: e.projectName,
+          checked: false
+        }))
+      ],
+      pageSize: 30
+    });
+    return result2;
+  }
+  return result;
+}
+
+// packages/cli/src/commands/launch.ts
+init_dist2();
 var CMUX_APP = "/Applications/cmux.app";
 var TEMPLATES_DIR4 = path23.join(os12.homedir(), ".config", "squadrant", "templates");
 var SESSIONS_PATH2 = path23.join(os12.homedir(), ".config", "squadrant", "sessions.json");
@@ -8559,12 +9131,43 @@ var launchCommand = new Command12("launch").description(
     }
     console.log("");
   } else if (!project) {
-    console.error(
-      chalk13.red(
-        "\n  \u2718 Specify a project name, or pass --all to launch every captain.\n    For one-shot Command tasks, use `squadrant command --task <briefing|learnings-review|wiki-aggregate>`.\n"
-      )
-    );
-    process.exit(1);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      console.error(
+        chalk13.red(
+          "\n  \u2718 Specify a project name, or pass --all to launch every captain.\n    For one-shot Command tasks, use `squadrant command --task <briefing|learnings-review|wiki-aggregate>`.\n"
+        )
+      );
+      process.exit(1);
+    }
+    ensureCmuxReady();
+    const sessions = loadSessions(SESSIONS_PATH2);
+    const entries = Object.entries(config.projects).map(([name, proj]) => ({
+      projectName: name,
+      captainName: proj.captainName,
+      lastLaunched: sessions.workspaces[proj.captainName]?.lastLaunched ?? null
+    }));
+    const selected = await selectCaptainsInteractive(entries);
+    if (selected.length === 0) {
+      console.log(chalk13.yellow("\n  No captains selected.\n"));
+      return;
+    }
+    console.log(chalk13.bold(`
+Launching ${selected.length} captain workspace(s) in parallel
+`));
+    await Promise.all(selected.map(async (name) => {
+      const proj = config.projects[name];
+      const projPath = resolveHome(proj.path);
+      const spokePath = resolveHome(proj.spokeVault);
+      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}`));
+      }
+      console.log(chalk13.bold(`
+  Captain: ${proj.captainName} (${name})`));
+      await launchOne(proj.captainName, "captain", projPath, config.defaults.permissions?.captain || "auto", false, true, name);
+    }));
+    console.log("");
   } else {
     if (!config.projects[project]) {
       console.error(
@@ -9561,7 +10164,7 @@ init_dist2();
 import { Command as Command22 } from "commander";
 import fs25 from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname5, join as join21 } from "path";
+import { dirname as dirname5, join as join23 } from "path";
 import chalk22 from "chalk";
 function runConfigCheck(opts) {
   const raw = JSON.parse(fs25.readFileSync(opts.configPath, "utf-8"));
@@ -9697,7 +10300,7 @@ configCommand.command("set").description("Write a config value by dotted key (e.
   }
 });
 function readPkgVersion2() {
-  const pkgPath = join21(dirname5(fileURLToPath5(import.meta.url)), "..", "package.json");
+  const pkgPath = join23(dirname5(fileURLToPath5(import.meta.url)), "..", "package.json");
   return JSON.parse(fs25.readFileSync(pkgPath, "utf-8")).version;
 }
 
@@ -9968,12 +10571,12 @@ var effortCommand = new Command26("effort").description("Get or set the global c
 // packages/cli/src/commands/telegram.ts
 init_dist();
 init_dist2();
-import { join as join22, dirname as dirname6 } from "path";
+import { join as join24, dirname as dirname6 } from "path";
 import { emitKeypressEvents } from "readline";
 import { Command as Command27 } from "commander";
 import chalk27 from "chalk";
 function defaultStateRoot() {
-  return join22(dirname6(DEFAULT_CONFIG_PATH), "state");
+  return join24(dirname6(DEFAULT_CONFIG_PATH), "state");
 }
 async function questionMasked() {
   return new Promise((resolve3) => {
@@ -10294,25 +10897,88 @@ telegramCommand.command("send").argument("<project>", "project whose topic recei
   }
 });
 
+// packages/cli/src/commands/hooks.ts
+init_dist2();
+init_dist4();
+import { Command as Command28 } from "commander";
+import { join as join25 } from "path";
+import { homedir as homedir17 } from "os";
+var SOCK4 = join25(homedir17(), ".config", "squadrant", "squadrant.sock");
+async function sendToSock(req) {
+  await sendRequest(SOCK4, req);
+}
+function mapHookSub(sub, payload, taskId) {
+  switch (sub) {
+    case "session-start":
+    case "prompt-submit":
+    case "pre-tool-use":
+      return { type: "task.progress", id: taskId, note: sub };
+    case "stop":
+      return mapClaudeHookToEvent("Stop", payload, taskId);
+    case "notification":
+      return mapClaudeHookToEvent("Notification", payload, taskId);
+    case "ask-question": {
+      const q = typeof payload?.question === "string" ? payload.question : "awaiting input";
+      return { type: "task.input.requested", id: taskId, requestId: 0, question: q };
+    }
+    case "session-end":
+      return mapClaudeHookToEvent("SessionEnd", payload, taskId);
+    default:
+      return null;
+  }
+}
+function hooksCommand() {
+  const hooks = new Command28("hooks").description("(internal) receive lifecycle hook events from agent processes");
+  hooks.command("claude <sub>", { hidden: true }).description("internal: bridge a NativeHookSource claude hook to squadrantd").action(async (sub) => {
+    const taskId = process.env.SQUADRANT_CREW_TASK_ID;
+    const project = process.env.SQUADRANT_CREW_PROJECT;
+    if (!taskId || !project) {
+      process.exit(0);
+    }
+    let stdin = "";
+    try {
+      for await (const chunk of process.stdin) stdin += chunk;
+    } catch {
+    }
+    let payload = void 0;
+    if (stdin.trim()) {
+      try {
+        payload = JSON.parse(stdin);
+      } catch {
+      }
+    }
+    const ev = mapHookSub(sub, payload, taskId);
+    if (!ev) {
+      process.exit(0);
+    }
+    try {
+      await sendToSock({ kind: "event", project, event: ev });
+    } catch {
+    }
+    process.exit(0);
+  });
+  return hooks;
+}
+
 // packages/cli/src/index.ts
 init_dist();
 init_dist();
 init_dist();
 var __dirname = dirname7(fileURLToPath6(import.meta.url));
-var pkg = JSON.parse(readFileSync11(join23(__dirname, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync13(join26(__dirname, "..", "package.json"), "utf-8"));
 ensureRuntimeSynced({
-  sourceRoot: join23(__dirname, ".."),
-  runtimeRoot: join23(homedir15(), ".config", "squadrant")
+  sourceRoot: join26(__dirname, ".."),
+  runtimeRoot: join26(homedir18(), ".config", "squadrant")
 });
 if (process.argv[2] !== "config") {
   try {
-    const cfgPath = join23(homedir15(), ".config", "squadrant", "config.json");
-    if (existsSync11(cfgPath)) {
-      const cfg = JSON.parse(readFileSync11(cfgPath, "utf-8"));
+    const cfgPath = join26(homedir18(), ".config", "squadrant", "config.json");
+    if (existsSync12(cfgPath)) {
+      const cfg = JSON.parse(readFileSync13(cfgPath, "utf-8"));
       if (needsCheck(cfg, pkg.version)) {
         const items = detectDrift(cfg, getDefaultConfig());
         if (items.length === 0) {
-          writeFileSync9(cfgPath, JSON.stringify(withStamp(cfg, pkg.version), null, 2) + "\n");
+          writeFileSync10(cfgPath, JSON.stringify(withStamp(cfg, pkg.version), null, 2) + "\n");
         } else {
           const from = cfg._squadrantVersion ?? "an earlier version";
           process.stderr.write(
@@ -10331,7 +10997,7 @@ if (process.argv[2] !== "config") {
 if (!process.env.SQUADRANT_DAEMON_SKIP) {
   ensureDaemon();
 }
-var program = new Command28();
+var program = new Command29();
 program.name("squadrant").description("Multi-project orchestration for your coding agents (Claude, Codex, opencode, Gemini)").version(pkg.version);
 program.addCommand(doctorCommand);
 program.addCommand(initCommand);
@@ -10358,6 +11024,7 @@ program.addCommand(groupCommand);
 program.addCommand(cmuxCommand);
 program.addCommand(effortCommand);
 program.addCommand(telegramCommand);
+program.addCommand(hooksCommand());
 program.parseAsync().catch((e) => {
   process.stderr.write(`error: ${e instanceof Error ? e.message : String(e)}
 `);