squadrant 0.12.1 → 0.13.1

package/dist/squadrantd.js

@@ -57,10 +57,10 @@ var init_snapshot = __esm({
 });
 
 // packages/cli/src/squadrantd.ts
-import { join as join15, dirname as dirname5 } from "path";
-import { homedir as homedir10 } from "os";
+import { join as join17, dirname as dirname5 } from "path";
+import { homedir as homedir12 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 
 // packages/shared/dist/config.js
 import fs from "fs";
@@ -1688,6 +1688,7 @@ var ERROR_BANNER_RE = [
   /\bmaximum\s+retries\b/i
 ];
 var OPTION_RE = /^[❯>›]?\s*(\d+)\.\s+(.*\S)\s*$/;
+var PICKER_FOOTER_RE = /↑↓\s*select|enter\s+submit|esc\s+dismiss/i;
 var PURE_CHROME_RE = /^[\s─━│┃╭╮╰╯┌┐└┘├┤┬┴┼═║╔╗╚╝╠╣╦╩╬▁▂▃▄▅▆▇█▔▏▕]+$/;
 var STATUS_LINE_RE = /accept edits on|shift\+tab|⏵⏵|\? for shortcuts|esc to interrupt|tokens? (used|left)|context left/i;
 function stripChrome(raw) {
@@ -1731,6 +1732,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)
@@ -3262,6 +3275,23 @@ import path10 from "path";
 var TEMPLATES_DIR = path10.join(os4.homedir(), ".config", "squadrant", "templates");
 var STATE_ROOT = path10.join(os4.homedir(), ".config", "squadrant", "state");
 
+// packages/core/dist/lifecycle-source.js
+function reduceLifecycle(prev, next) {
+  if (next.origin === "agent") {
+    return next.state;
+  }
+  if (next.state === "needsInput") {
+    return prev?.state ?? "unknown";
+  }
+  if (prev?.state === "needsInput") {
+    return "needsInput";
+  }
+  if (prev?.origin === "agent" && prev.at >= next.at) {
+    return prev.state;
+  }
+  return next.state;
+}
+
 // packages/agents/dist/drivers/claude.js
 import { execSync as execSync2 } from "child_process";
 
@@ -3480,6 +3510,87 @@ function defaultSpawn() {
   return nodeSpawn("codex", ["app-server"], { stdio: ["pipe", "pipe", "pipe"] });
 }
 
+// packages/agents/dist/codex/codex-app-server-source.js
+var 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);
+  }
+};
+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;
+  }
+}
+
 // packages/agents/dist/codex/config.js
 import { readFile as readFile5 } from "fs/promises";
 import { homedir as homedir8 } from "os";
@@ -4709,17 +4820,346 @@ var DaemonCmux = class {
   }
 };
 
+// packages/workspaces/dist/cmux-daemon/cmux-store-source.js
+import { join as join15 } from "path";
+import { homedir as homedir10 } from "os";
+import { watch, readdirSync as readdirSync3, readFileSync as readFileSync9, existsSync as existsSync10 } from "fs";
+var 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 ?? join15(homedir10(), ".cmuxterm");
+    this.debounceMs = opts.debounceMs ?? 50;
+    this.isPidAlive = opts.isPidAlive ?? defaultIsPidAlive2;
+    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 = join15(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);
+  }
+};
+function parseLifecycleState(s) {
+  if (s === "running" || s === "idle" || s === "needsInput" || s === "unknown") {
+    return s;
+  }
+  return "unknown";
+}
+function defaultIsPidAlive2(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(path17) {
+  try {
+    return readFileSync9(path17, "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();
+}
+
+// packages/workspaces/dist/native-hooks/native-hook-source.js
+import { join as join16 } from "path";
+import { homedir as homedir11 } from "os";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+var CLAUDE_HOOK_EVENTS = [
+  ["SessionStart", "session-start"],
+  ["UserPromptSubmit", "prompt-submit"],
+  ["PreToolUse", "pre-tool-use"],
+  ["Stop", "stop"],
+  ["Notification", "notification"],
+  ["PreToolUse", "ask-question", "AskUserQuestion"],
+  ["SessionEnd", "session-end"]
+];
+var DEFAULT_HOOK_CMD = "squadrant hooks";
+function installClaudeHooks(opts = {}) {
+  const settingsPath = opts.settingsPath ?? join16(homedir11(), ".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;
+  }
+}
+var 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);
+  }
+};
+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(path17) {
+  try {
+    return readFileSync10(path17, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function defaultWriteFile(path17, content) {
+  mkdirSync6(path17.replace(/\/[^/]+$/, ""), { recursive: true });
+  writeFileSync7(path17, content, "utf-8");
+}
+
 // packages/workspaces/dist/crew-pane.js
 import net from "net";
 
 // packages/cli/src/squadrantd.ts
 var SELF_PATH2 = fileURLToPath3(import.meta.url);
-var CLI_BIN = join15(dirname5(SELF_PATH2), "index.js");
-var DAEMON_SOCK = join15(homedir10(), ".config", "squadrant", "squadrant.sock");
+var CLI_BIN = join17(dirname5(SELF_PATH2), "index.js");
+var DAEMON_SOCK = join17(homedir12(), ".config", "squadrant", "squadrant.sock");
 function readPkgVersion() {
   try {
-    const pkgPath = join15(dirname5(SELF_PATH2), "..", "package.json");
-    return JSON.parse(readFileSync9(pkgPath, "utf-8")).version ?? "unknown";
+    const pkgPath = join17(dirname5(SELF_PATH2), "..", "package.json");
+    return JSON.parse(readFileSync11(pkgPath, "utf-8")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -4757,6 +5197,7 @@ function startSquadrantd(opts = {}) {
   ctx.broadcast = broadcast;
   ctx.schedulePromotion = schedulePromotion;
   ctx.cancelPromotionsFor = cancelPromotionsFor;
+  const codexAppServerSource = new CodexAppServerSource();
   const codexDriver = opts.codexDriver ?? new CodexInteractiveDriver({
     emit: (ev) => {
       const found = ctx.store.listAll().find((r) => r.id === ev.id);
@@ -4776,6 +5217,7 @@ function startSquadrantd(opts = {}) {
         ctx.schedulePromotion(ev.id, ev.requestId, "approval", ev.question);
       } else if (ev.type === "task.reattached")
         ctx.broadcast(ev.id, { type: "reattached", taskId: ev.id });
+      codexAppServerSource.observe(ev);
     }
   });
   const opencodeBridge = opts.opencodeBridge ?? new OpencodeSseBridge({
@@ -4800,9 +5242,11 @@ function startSquadrantd(opts = {}) {
         (r) => r.mode === "interactive" && !TERMINAL_STATES.has(r.state) && r.cwd === hook.cwd
       );
     },
-    cursorFile: join15(stateRoot, "cmux-events.seq"),
+    cursorFile: join17(stateRoot, "cmux-events.seq"),
     log
   });
+  const cmuxStoreSource = new CmuxStoreSource({ log });
+  const nativeHookSource = new NativeHookSource({ log });
   ctx.codexDriver = codexDriver;
   ctx.opencodeBridge = opencodeBridge;
   ctx.cmuxEventsBridge = cmuxEventsBridge;
@@ -4830,7 +5274,135 @@ function startSquadrantd(opts = {}) {
       activeHeadlessKills.delete(handle.kill);
     }
   });
-  return startDaemon(ctx, { ...opts, launchHeadless }, PKG_VERSION);
+  const h = startDaemon(ctx, { ...opts, launchHeadless }, PKG_VERSION);
+  if (!process.env.VITEST) {
+    const prevSnaps = /* @__PURE__ */ new Map();
+    const storeDeps = {
+      resolve: (hint) => {
+        if (!hint.cwd && hint.pid == null) return void 0;
+        return store.listAll().find(
+          (r) => r.mode === "interactive" && !TERMINAL_STATES.has(r.state) && (r.cwd === hint.cwd || hint.pid != null && r.pid === hint.pid)
+        );
+      },
+      report: (snap) => {
+        const found = store.listAll().find((r) => r.id === snap.taskId);
+        if (!found) return;
+        const prev = prevSnaps.get(snap.taskId);
+        const newState = reduceLifecycle(prev, snap);
+        const changed = !prev || newState !== prev.state;
+        prevSnaps.set(snap.taskId, snap);
+        if (!snap.alive) {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.session.ended", id: snap.taskId } });
+          return;
+        }
+        if (!changed) return;
+        if (newState === "idle") {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.turn.completed", id: snap.taskId, turnId: "cmux-store" } });
+        } else if (newState === "running") {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.progress", id: snap.taskId } });
+        } else if (newState === "needsInput") {
+          const question = snap.detail?.note ?? snap.detail?.reason ?? "crew awaiting input";
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.blocked", id: snap.taskId, reason: "needsInput", question } });
+        }
+      },
+      log
+    };
+    try {
+      cmuxStoreSource.start(storeDeps);
+    } catch (e) {
+      log(`cmux store source start failed: ${e.message}`);
+    }
+    try {
+      nativeHookSource.install();
+    } catch (e) {
+      log(`native hook install failed: ${e.message}`);
+    }
+    const hookPrevSnaps = /* @__PURE__ */ new Map();
+    const hookDeps = {
+      resolve: (hint) => {
+        if (!hint.cwd && hint.pid == null) return void 0;
+        return store.listAll().find(
+          (r) => r.mode === "interactive" && !TERMINAL_STATES.has(r.state) && (r.cwd === hint.cwd || hint.pid != null && r.pid === hint.pid)
+        );
+      },
+      report: (snap) => {
+        const found = store.listAll().find((r) => r.id === snap.taskId);
+        if (!found) return;
+        const prev = hookPrevSnaps.get(snap.taskId);
+        const newState = reduceLifecycle(prev, snap);
+        const changed = !prev || newState !== prev.state;
+        hookPrevSnaps.set(snap.taskId, snap);
+        if (!snap.alive) {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.session.ended", id: snap.taskId } });
+          return;
+        }
+        if (!changed) return;
+        if (newState === "idle") {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.turn.completed", id: snap.taskId, turnId: "native-hook" } });
+        } else if (newState === "running") {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.progress", id: snap.taskId } });
+        } else if (newState === "needsInput") {
+          const question = snap.detail?.note ?? snap.detail?.reason ?? "crew awaiting input";
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.blocked", id: snap.taskId, reason: "needsInput", question } });
+        }
+      },
+      log
+    };
+    try {
+      nativeHookSource.start(hookDeps);
+    } catch (e) {
+      log(`native hook source start failed: ${e.message}`);
+    }
+    const codexPrevSnaps = /* @__PURE__ */ new Map();
+    const codexSourceDeps = {
+      resolve: () => void 0,
+      // taskId comes from ControlEvent.id; resolve() unused
+      report: (snap) => {
+        const found = store.listAll().find((r) => r.id === snap.taskId);
+        if (!found) return;
+        const prev = codexPrevSnaps.get(snap.taskId);
+        const newState = reduceLifecycle(prev, snap);
+        const changed = !prev || newState !== prev.state;
+        codexPrevSnaps.set(snap.taskId, snap);
+        if (!snap.alive) {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.session.ended", id: snap.taskId } });
+          return;
+        }
+        if (!changed) return;
+        if (newState === "idle") {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.turn.completed", id: snap.taskId, turnId: "codex-appserver" } });
+        } else if (newState === "running") {
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.progress", id: snap.taskId } });
+        } else if (newState === "needsInput") {
+          const question = snap.detail?.note ?? snap.detail?.reason ?? "crew awaiting input";
+          void ctx.d.handle({ kind: "event", project: found.project, event: { type: "task.blocked", id: snap.taskId, reason: "needsInput", question } });
+        }
+      },
+      log
+    };
+    try {
+      codexAppServerSource.start(codexSourceDeps);
+    } catch (e) {
+      log(`codex app-server source start failed: ${e.message}`);
+    }
+  }
+  const origStop = h.stop.bind(h);
+  h.stop = async () => {
+    try {
+      cmuxStoreSource.stop();
+    } catch {
+    }
+    try {
+      nativeHookSource.stop();
+    } catch {
+    }
+    try {
+      codexAppServerSource.stop();
+    } catch {
+    }
+    return origStop();
+  };
+  return h;
 }
 if (process.argv[1] && process.argv[1].endsWith("squadrantd.js")) {
   void (async () => {
@@ -4839,7 +5411,7 @@ if (process.argv[1] && process.argv[1].endsWith("squadrantd.js")) {
       process.stdout.write("squadrantd: launchd-managed daemon entry (no CLI args). Use `squadrant` for commands.\n");
       process.exit(0);
     }
-    const sock = join15(homedir10(), ".config", "squadrant", "squadrant.sock");
+    const sock = join17(homedir12(), ".config", "squadrant", "squadrant.sock");
     if (await isDaemonSocketLive(sock)) {
       process.stderr.write(`[squadrantd] refusing to start: a live daemon already owns ${sock}
 `);