squadrant 0.19.1 → 0.19.3

package/dist/squadrantd.js

@@ -199,8 +199,8 @@ function deepMerge(base, patch) {
   if (patch === null || typeof patch !== "object" || Array.isArray(patch))
     return patch ?? base;
   const out = { ...base };
-  for (const [k, v] of Object.entries(patch)) {
-    out[k] = deepMerge(out[k], v);
+  for (const [k, v2] of Object.entries(patch)) {
+    out[k] = deepMerge(out[k], v2);
   }
   return out;
 }
@@ -676,8 +676,8 @@ var init_runtime_sync = __esm({
 });
 
 // packages/shared/dist/lib/tool-compat.js
-function parseSemVer(v) {
-  const m = v.match(/(\d+)\.(\d+)\.(\d+)/);
+function parseSemVer(v2) {
+  const m = v2.match(/(\d+)\.(\d+)\.(\d+)/);
   if (!m)
     return null;
   return [parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)];
@@ -1823,12 +1823,12 @@ function isDaemonSocketLive(sockPath, timeoutMs = 500) {
       return;
     }
     const conn = createConnection(sockPath);
-    const finish = (v) => {
+    const finish = (v2) => {
       try {
         conn.destroy();
       } catch {
       }
-      resolve4(v);
+      resolve4(v2);
     };
     const timer = setTimeout(() => finish(false), timeoutMs);
     conn.on("connect", () => {
@@ -2494,17 +2494,20 @@ function getDaemonPid(target) {
 function forceKickstartAndVerify(target, opts = {}) {
   const pollAttempts = opts.pollAttempts ?? 15;
   const pollDelayMs = opts.pollDelayMs ?? 300;
-  const kickstartRetries = opts.kickstartRetries ?? 5;
+  const kickstartRetries = opts.kickstartRetries ?? 10;
   const kickstartRetryDelayMs = opts.kickstartRetryDelayMs ?? 300;
   const pidBefore = getDaemonPid(target);
+  let kickstartError = null;
   for (let i = 0; i < kickstartRetries; i++) {
     try {
       execFileSync3("launchctl", ["kickstart", "-k", target], { stdio: "ignore" });
+      kickstartError = null;
       break;
     } catch (e) {
-      if (i === kickstartRetries - 1)
-        throw e;
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, kickstartRetryDelayMs);
+      kickstartError = e;
+      if (i < kickstartRetries - 1) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, kickstartRetryDelayMs);
+      }
     }
   }
   let pidAfter = null;
@@ -2516,7 +2519,16 @@ function forceKickstartAndVerify(target, opts = {}) {
       Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, pollDelayMs);
     }
   }
-  return { target, pidBefore, pidAfter, restarted: pidAfter !== null && pidAfter !== pidBefore };
+  const restarted = pidAfter !== null && pidAfter !== pidBefore;
+  if (kickstartError && !restarted)
+    throw kickstartError;
+  return {
+    target,
+    pidBefore,
+    pidAfter,
+    restarted,
+    ...kickstartError ? { note: "kickstart -k refused; daemon restarted by bootstrap" } : {}
+  };
 }
 function isOperatorInitiatedCommand(topLevelArg) {
   return topLevelArg !== void 0 && OPERATOR_INITIATED_COMMANDS.has(topLevelArg);
@@ -3425,6 +3437,38 @@ import fs9 from "fs";
 import os4 from "os";
 import path9 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
+function ensureSocksDir(dir = CC_SOCKS_DIR) {
+  fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+  if ((fs9.statSync(dir).mode & 511) !== 448)
+    fs9.chmodSync(dir, 448);
+}
+async function pollFirstTurnConfirmedAt(getTaskRecord, project, id) {
+  const deadline = Date.now() + FIRST_TURN_HOOK_CONFIRM_WINDOW_MS;
+  for (; ; ) {
+    const rec = await getTaskRecord(project, id).catch(() => void 0);
+    if (rec?.firstTurnConfirmedAt)
+      return true;
+    if (Date.now() >= deadline)
+      return false;
+    await new Promise((r) => setTimeout(r, FIRST_TURN_HOOK_POLL_INTERVAL_MS));
+  }
+}
+function firstTrueOrBothFalse(a, b) {
+  return new Promise((resolve4) => {
+    let settledFalseCount = 0;
+    const onSettle = (ok2) => {
+      if (ok2) {
+        resolve4(true);
+        return;
+      }
+      settledFalseCount++;
+      if (settledFalseCount === 2)
+        resolve4(false);
+    };
+    a.then(onSettle, () => onSettle(false));
+    b.then(onSettle, () => onSettle(false));
+  });
+}
 async function listCrewPanes(runtime, workspaceId, project) {
   const surfaces = await runtime.listSurfaces(workspaceId);
   return surfaces.filter((s) => s.title && isCrewTitle(project, s.title));
@@ -3535,7 +3579,7 @@ async function runCrewSpawn(input, config, deps) {
     deps.onModelResolved?.({ agentName, model: crewModel });
   }
   if (agentName === "claude") {
-    fs9.mkdirSync(CC_SOCKS_DIR, { recursive: true });
+    ensureSocksDir();
     const messagingSocketPath = path9.join(CC_SOCKS_DIR, `squadrant-${randomUUID3()}.sock`);
     const rec = await deps.dispatchCrew({
       provider: "claude",
@@ -3581,10 +3625,12 @@ async function runCrewSpawn(input, config, deps) {
       fs9.writeFileSync(spillFile, claudeFirstTurn, "utf8");
       claudeFirstTurn = `Full task is at ${spillFile} \u2014 cat it and follow it exactly.`;
     }
-    const claudeResult = await deps.sendFirstTurn(pane2, `${claudeFirstTurn}
+    const sendPromise = deps.sendFirstTurn(pane2, `${claudeFirstTurn}
 
 ${buildCompletionProtocol(rec.id, input.project)}`, preLaunchScreen);
-    if (!claudeResult.delivered) {
+    const scrapeDelivered = sendPromise.then((r) => r.delivered).catch(() => false);
+    const delivered = hooksInstalled && deps.getTaskRecord ? await firstTrueOrBothFalse(scrapeDelivered, pollFirstTurnConfirmedAt(deps.getTaskRecord, input.project, rec.id)) : await scrapeDelivered;
+    if (!delivered) {
       process.stderr.write(`\u26A0\uFE0F  First turn not delivered for crew '${name}' \u2014 use 'squadrant crew send ${input.project} ${name}' to re-send the task.
 `);
     } else if (!hooksInstalled) {
@@ -3695,6 +3741,10 @@ async function runCrewSend(project, name, message, runtime, workspaceId, deps, o
     const heldForMin = Math.round((Date.now() - task.operatorHold.since) / 6e4);
     throw new Error(`Crew '${name}' is under operator takeover (held ${heldForMin}m${task.operatorHold.note ? `: ${task.operatorHold.note}` : ""}). The operator is working in that tab \u2014 sending a message disrupts their conversation. Ask them to run 'squadrant crew handback ${project} ${name}', or pass --force if they told you to.`);
   }
+  const isAttentionState = task?.state === "blocked" || task?.state === "awaiting-input" || task?.state === "review";
+  if (task && !isAttentionState && task.firstTurnConfirmedAt && task.task === message) {
+    throw new Error(`Crew '${name}' already confirmed receipt of this task \u2014 its first turn was delivered and is not being re-sent to avoid running it twice. If you have new instructions, send different text.`);
+  }
   let reopened = false;
   try {
     if (task) {
@@ -3861,7 +3911,7 @@ async function runCrewList(project, runtime, workspaceId) {
     surfaceId: c.surfaceId
   }));
 }
-var CC_SOCKS_DIR, FIRST_TURN_INLINE_MAX_BYTES, TEMPLATES_DIR, STATE_ROOT, CLOSE_LOOKUP_RETRIES, CLOSE_LOOKUP_RETRY_DELAY_MS;
+var CC_SOCKS_DIR, FIRST_TURN_INLINE_MAX_BYTES, TEMPLATES_DIR, STATE_ROOT, FIRST_TURN_HOOK_CONFIRM_WINDOW_MS, FIRST_TURN_HOOK_POLL_INTERVAL_MS, CLOSE_LOOKUP_RETRIES, CLOSE_LOOKUP_RETRY_DELAY_MS;
 var init_crew_spawn = __esm({
   "packages/core/dist/crew-spawn.js"() {
     init_control_channel();
@@ -3873,6 +3923,8 @@ var init_crew_spawn = __esm({
     FIRST_TURN_INLINE_MAX_BYTES = 1200;
     TEMPLATES_DIR = path9.join(os4.homedir(), ".config", "squadrant", "templates");
     STATE_ROOT = path9.join(os4.homedir(), ".config", "squadrant", "state");
+    FIRST_TURN_HOOK_CONFIRM_WINDOW_MS = 1e5;
+    FIRST_TURN_HOOK_POLL_INTERVAL_MS = 2e3;
     CLOSE_LOOKUP_RETRIES = 3;
     CLOSE_LOOKUP_RETRY_DELAY_MS = 150;
   }
@@ -4042,9 +4094,9 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
   const lastDeferred = /* @__PURE__ */ new Map();
   const inFlightDelivery = () => {
     let worst = null;
-    for (const [project, v] of lastDeferred) {
-      if (!worst || v.deferCount > worst.deferCount)
-        worst = { project, ...v };
+    for (const [project, v2] of lastDeferred) {
+      if (!worst || v2.deferCount > worst.deferCount)
+        worst = { project, ...v2 };
     }
     return worst;
   };
@@ -6408,6 +6460,326 @@ var init_lifecycle_source = __esm({
   }
 });
 
+// packages/core/dist/events/fact.js
+function stampFact(raw, id) {
+  return { ...raw, ...id };
+}
+var init_fact = __esm({
+  "packages/core/dist/events/fact.js"() {
+  }
+});
+
+// packages/core/dist/events/log.js
+var FactLog;
+var init_log = __esm({
+  "packages/core/dist/events/log.js"() {
+    FactLog = class {
+      capacity;
+      buffers = /* @__PURE__ */ new Map();
+      constructor(opts = {}) {
+        this.capacity = opts.capacity ?? 256;
+      }
+      push(fact) {
+        let buf = this.buffers.get(fact.taskId);
+        if (!buf) {
+          buf = [];
+          this.buffers.set(fact.taskId, buf);
+        }
+        buf.push(fact);
+        while (buf.length > this.capacity)
+          buf.shift();
+      }
+      /** Oldest-first snapshot. A fresh array; later pushes never grow it. */
+      recent(taskId) {
+        return [...this.buffers.get(taskId) ?? []];
+      }
+      /** Newline-delimited JSON, one fact per line, oldest first. */
+      serialize(taskId) {
+        return this.recent(taskId).map((f) => JSON.stringify(f)).join("\n") + "\n";
+      }
+      /** Release a finished crew's buffer. */
+      drop(taskId) {
+        this.buffers.delete(taskId);
+      }
+    };
+  }
+});
+
+// packages/core/dist/events/invariant.js
+function freshTrace() {
+  return {
+    depth: 0,
+    oldestOpenAt: null,
+    stallReported: false,
+    unknownSeen: 0,
+    liveness: /* @__PURE__ */ new Map()
+  };
+}
+function checkFact(trace, fact, opts) {
+  const out = [];
+  if (fact.origin === "inferred" && TERMINALISING.has(fact.kind)) {
+    out.push(v("I4", `inferred fact "${fact.kind}" from ${fact.source} cannot terminalise alone`, fact));
+  }
+  switch (fact.kind) {
+    case "tool.opened":
+      if (trace.depth === 0) {
+        trace.oldestOpenAt = fact.at;
+        trace.stallReported = false;
+      }
+      trace.depth += 1;
+      break;
+    case "tool.closed":
+      if (trace.depth === 0) {
+        out.push(v("I1", `tool.closed from ${fact.source} with no open tool`, fact));
+      } else {
+        trace.depth -= 1;
+        if (trace.depth === 0) {
+          trace.oldestOpenAt = null;
+          trace.stallReported = false;
+        }
+      }
+      break;
+    case "turn.ended":
+      if (trace.depth > 0) {
+        out.push(v("I2", `turn.ended with ${trace.depth} tool call(s) still open`, fact));
+        trace.depth = 0;
+        trace.oldestOpenAt = null;
+        trace.stallReported = false;
+      }
+      break;
+    case "unknown":
+      trace.unknownSeen += 1;
+      out.push(v("I5", `unrecognised frame "${fact.name}" from ${fact.source}`, fact));
+      break;
+    case "process.observed": {
+      const prior = [...trace.liveness.entries()].find(([src, s]) => src !== fact.source && s.alive !== fact.alive && fact.at - s.at <= (opts.disagreeWindowMs ?? -1));
+      if (prior) {
+        out.push(v("I6", `liveness disagreement: ${prior[0]} said alive=${prior[1].alive}, ${fact.source} says alive=${fact.alive}`, fact));
+      }
+      trace.liveness.set(fact.source, { alive: fact.alive, at: fact.at });
+      break;
+    }
+    default:
+      break;
+  }
+  if (opts.stallBudgetMs !== void 0 && trace.depth > 0 && trace.oldestOpenAt !== null && !trace.stallReported && fact.at - trace.oldestOpenAt > opts.stallBudgetMs) {
+    trace.stallReported = true;
+    out.push(v("I3", `tool open for ${fact.at - trace.oldestOpenAt}ms, past the stall budget`, fact));
+  }
+  return out;
+}
+var v, TERMINALISING;
+var init_invariant = __esm({
+  "packages/core/dist/events/invariant.js"() {
+    v = (code, message, f) => ({ code, message, taskId: f.taskId, at: f.at });
+    TERMINALISING = /* @__PURE__ */ new Set(["session.ended"]);
+  }
+});
+
+// packages/core/dist/events/to-control-event.js
+function toControlEvent(fact) {
+  if (fact.origin === "inferred" && TERMINALISING2.has(fact.kind))
+    return [];
+  switch (fact.kind) {
+    case "turn.ended":
+      return [{ type: "task.turn.completed", id: fact.taskId, turnId: fact.turnId ?? fact.source }];
+    case "permission.requested":
+      return [{
+        type: "task.approval.requested",
+        id: fact.taskId,
+        requestId: fact.requestId,
+        question: fact.question,
+        kind: fact.tool
+      }];
+    case "input.requested":
+      return [{
+        type: "task.input.requested",
+        id: fact.taskId,
+        requestId: fact.requestId,
+        question: fact.question
+      }];
+    case "session.ended":
+      return [{ type: "task.session.ended", id: fact.taskId }];
+    case "session.started":
+      return [{
+        type: "task.started",
+        id: fact.taskId,
+        ...fact.pid === void 0 ? {} : { pid: fact.pid },
+        ...fact.sessionId === void 0 ? {} : { sessionId: fact.sessionId }
+      }];
+    case "prompt.submitted":
+      return [{ type: "task.first-turn.confirmed", id: fact.taskId }];
+    // Liveness-only. The facade still feeds these to reduceLifecycle; they
+    // simply carry no ControlEvent of their own.
+    case "tool.opened":
+    case "tool.closed":
+    case "activity":
+    case "process.observed":
+    case "unknown":
+      return [];
+  }
+}
+var TERMINALISING2;
+var init_to_control_event = __esm({
+  "packages/core/dist/events/to-control-event.js"() {
+    TERMINALISING2 = /* @__PURE__ */ new Set(["session.ended"]);
+  }
+});
+
+// packages/core/dist/events/conformance.js
+function assert(cond, msg) {
+  if (!cond)
+    throw new Error(`conformance: ${msg}`);
+}
+function runAdapterConformance(adapter, samples) {
+  const call = (raw) => adapter.translate(raw);
+  return [
+    {
+      name: `${adapter.name}: never throws on garbage`,
+      run: () => {
+        for (const g of GARBAGE) {
+          try {
+            call(g);
+          } catch (e) {
+            throw new Error(`threw on ${JSON.stringify(g)}: ${String(e)}`);
+          }
+        }
+      }
+    },
+    {
+      name: `${adapter.name}: never returns null or undefined`,
+      run: () => {
+        for (const g of [...GARBAGE, ...samples]) {
+          const out = call(g);
+          assert(Array.isArray(out), `returned a non-array for ${JSON.stringify(g)}`);
+        }
+      }
+    },
+    {
+      name: `${adapter.name}: an unrecognised frame yields unknown, not an empty array`,
+      run: () => {
+        const out = call({ type: "definitely-not-a-real-event-name" });
+        assert(out.length > 0, "silently dropped an unrecognised frame (the #542 shape)");
+        assert(out.every((f) => f.kind === "unknown"), "an unrecognised frame must translate to kind 'unknown'");
+      }
+    },
+    {
+      name: `${adapter.name}: recognises its own samples`,
+      run: () => {
+        for (const s of samples) {
+          const out = call(s);
+          assert(out.length > 0, `produced nothing for its own sample ${JSON.stringify(s)}`);
+          assert(out.some((f) => f.kind !== "unknown"), `failed to recognise its own sample ${JSON.stringify(s)}`);
+        }
+      }
+    },
+    {
+      name: `${adapter.name}: declares a constant origin`,
+      run: () => {
+        assert(adapter.origin === "agent" || adapter.origin === "scan" || adapter.origin === "inferred", `invalid origin "${String(adapter.origin)}"`);
+      }
+    }
+  ];
+}
+var GARBAGE;
+var init_conformance = __esm({
+  "packages/core/dist/events/conformance.js"() {
+    GARBAGE = [
+      null,
+      void 0,
+      0,
+      "",
+      "not json",
+      [],
+      {},
+      { type: 42 },
+      { type: "definitely-not-a-real-event-name" }
+    ];
+  }
+});
+
+// packages/core/dist/events/source.js
+function createEventsSource(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const log = new FactLog({ capacity: opts.capacity });
+  const adapters = new Map(opts.adapters.map((a) => [a.name, a]));
+  const traces = /* @__PURE__ */ new Map();
+  const seqs = /* @__PURE__ */ new Map();
+  let deps;
+  const traceFor = (taskId) => {
+    let t = traces.get(taskId);
+    if (!t) {
+      t = freshTrace();
+      traces.set(taskId, t);
+    }
+    return t;
+  };
+  const nextSeq = (taskId) => {
+    const n = seqs.get(taskId) ?? 0;
+    seqs.set(taskId, n + 1);
+    return n;
+  };
+  return {
+    name: "events",
+    start(d) {
+      deps = d;
+    },
+    stop() {
+      deps = void 0;
+    },
+    health() {
+      return { active: deps !== void 0, error: null };
+    },
+    recent(taskId) {
+      return log.recent(taskId);
+    },
+    dump(taskId) {
+      return log.serialize(taskId);
+    },
+    ingest(source, raw, hint) {
+      const adapter = adapters.get(source);
+      if (!adapter || !deps)
+        return;
+      const rec = deps.resolve(hint);
+      if (!rec)
+        return;
+      const taskId = rec.id;
+      const at = now();
+      let produced;
+      try {
+        const out = adapter.translate(raw);
+        produced = Array.isArray(out) ? out : [{ kind: "unknown", name: `${source} returned non-array` }];
+      } catch (e) {
+        opts.log?.(`events: adapter ${source} threw: ${String(e)}`);
+        produced = [{ kind: "unknown", name: `${source} threw` }];
+      }
+      for (const rawFact of produced) {
+        const fact = stampFact(rawFact, {
+          seq: nextSeq(taskId),
+          taskId,
+          at,
+          source,
+          origin: adapter.origin
+        });
+        log.push(fact);
+        for (const v2 of checkFact(traceFor(taskId), fact, opts.check ?? {})) {
+          opts.onViolation(v2);
+        }
+        for (const ev of toControlEvent(fact))
+          opts.emit(ev);
+      }
+    }
+  };
+}
+var init_source = __esm({
+  "packages/core/dist/events/source.js"() {
+    init_fact();
+    init_log();
+    init_invariant();
+    init_to_control_event();
+  }
+});
+
 // packages/core/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -6422,6 +6794,7 @@ __export(dist_exports, {
   DEFAULT_TASK_TIMEOUT_MS: () => DEFAULT_TASK_TIMEOUT_MS,
   DeferDelivery: () => DeferDelivery,
   FIRST_TURN_INLINE_MAX_BYTES: () => FIRST_TURN_INLINE_MAX_BYTES,
+  FactLog: () => FactLog,
   GROUP_DISPATCH_WARMUP_POLL_MS: () => GROUP_DISPATCH_WARMUP_POLL_MS,
   GROUP_DISPATCH_WARMUP_TIMEOUT_MS: () => GROUP_DISPATCH_WARMUP_TIMEOUT_MS,
   IDLE_DEBOUNCE_MS: () => IDLE_DEBOUNCE_MS,
@@ -6451,6 +6824,7 @@ __export(dist_exports, {
   capAllowed: () => capAllowed,
   capOutput: () => capOutput,
   captainSocketPath: () => captainSocketPath,
+  checkFact: () => checkFact,
   classifyHealth: () => classifyHealth,
   closeWorkItem: () => closeWorkItem,
   computeTemplateHash: () => computeTemplateHash,
@@ -6463,6 +6837,7 @@ __export(dist_exports, {
   createDirectCrewPaneReader: () => createDirectCrewPaneReader,
   createDirectSurfaceLivenessProbe: () => createDirectSurfaceLivenessProbe,
   createEnsureCaptainAlive: () => createEnsureCaptainAlive,
+  createEventsSource: () => createEventsSource,
   createInteractiveProbe: () => createInteractiveProbe,
   createIsCaptainAlive: () => createIsCaptainAlive,
   createLaunch: () => createLaunch,
@@ -6494,6 +6869,7 @@ __export(dist_exports, {
   encodeFrame: () => encodeFrame,
   encodeMsg: () => encodeMsg,
   ensureDaemon: () => ensureDaemon,
+  ensureSocksDir: () => ensureSocksDir,
   evaluateStall: () => evaluateStall,
   exitMarkerPath: () => exitMarkerPath,
   fallsBackToPane: () => fallsBackToPane,
@@ -6505,6 +6881,7 @@ __export(dist_exports, {
   formatInbound: () => formatInbound,
   formatInboundReceipt: () => formatInboundReceipt,
   formatLifecycle: () => formatLifecycle,
+  freshTrace: () => freshTrace,
   getDaemonPid: () => getDaemonPid,
   healCmdFor: () => healCmdFor,
   isAuthorized: () => isAuthorized,
@@ -6561,6 +6938,7 @@ __export(dist_exports, {
   resolveSetupUserId: () => resolveSetupUserId,
   restartDaemonIfRunning: () => restartDaemonIfRunning,
   rotateIfNeeded: () => rotateIfNeeded,
+  runAdapterConformance: () => runAdapterConformance,
   runCrewAnswer: () => runCrewAnswer,
   runCrewClose: () => runCrewClose,
   runCrewList: () => runCrewList,
@@ -6595,12 +6973,14 @@ __export(dist_exports, {
   sideNameFromTitle: () => sideNameFromTitle,
   sideNextAutoName: () => sideNextAutoName,
   sideTitleFor: () => sideTitleFor,
+  stampFact: () => stampFact,
   startDaemon: () => startDaemon,
   startServer: () => startServer,
   stripBotMention: () => stripBotMention,
   surfaceVerdict: () => surfaceVerdict,
   timeoutGate: () => timeoutGate,
   titleFor: () => titleFor,
+  toControlEvent: () => toControlEvent,
   topicKey: () => topicKey,
   topicName: () => topicName,
   tryAcquireDaemonLock: () => tryAcquireDaemonLock,
@@ -6647,6 +7027,12 @@ var init_dist2 = __esm({
     init_crew_spawn();
     init_crew_answer();
     init_lifecycle_source();
+    init_fact();
+    init_log();
+    init_invariant();
+    init_to_control_event();
+    init_conformance();
+    init_source();
     init_control_channel();
     init_captain_channel();
   }
@@ -6663,6 +7049,7 @@ init_dist2();
 init_dist2();
 init_dist2();
 init_dist2();
+init_dist2();
 import { join as join22, dirname as dirname4, resolve as resolve3 } from "path";
 import { homedir as homedir13 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -7301,9 +7688,9 @@ ${directive}` : directive;
 function withTimeout(p, ms, msg) {
   return new Promise((resolve4, reject) => {
     const t = setTimeout(() => reject(new Error(msg)), ms);
-    p.then((v) => {
+    p.then((v2) => {
       clearTimeout(t);
-      resolve4(v);
+      resolve4(v2);
     }, (e) => {
       clearTimeout(t);
       reject(e);
@@ -7312,6 +7699,7 @@ function withTimeout(p, ms, msg) {
 }
 
 // packages/agents/dist/opencode/sse-bridge.js
+var IGNORED_FRAME = /^(message|storage|file|lsp|installation)\./;
 var OpencodeSseBridge = class {
   controllers = /* @__PURE__ */ new Map();
   /** taskId → the crew's opencode server port (for permission-reply POSTs). */
@@ -7448,6 +7836,10 @@ var OpencodeSseBridge = class {
       return;
     }
     if (json?.type === "session.idle") {
+      if (this.deps.ingest) {
+        this.deps.ingest(json, taskId);
+        return;
+      }
       this.deps.emit({
         type: "task.turn.completed",
         id: taskId,
@@ -7457,6 +7849,10 @@ var OpencodeSseBridge = class {
       const p = json.properties;
       if (p?.id && p?.sessionID) {
         this.pendingPermByTask.set(taskId, { permID: p.id, sessionID: p.sessionID });
+        if (this.deps.ingest) {
+          this.deps.ingest(json, taskId);
+          return;
+        }
         const tool = p.permission ?? "a tool";
         const cmd = Array.isArray(p.patterns) && p.patterns.length ? `: ${p.patterns.join(" ")}` : "";
         this.deps.emit({
@@ -7466,11 +7862,24 @@ var OpencodeSseBridge = class {
           question: `opencode requests permission to run ${tool}${cmd}`,
           kind: tool
         });
+      } else if (this.deps.ingest) {
+        this.deps.ingest(json, taskId);
       }
     } else if (json?.type === "permission.replied") {
       this.pendingPermByTask.delete(taskId);
+      this.deps.ingest?.(json, taskId);
+    } else if (!IGNORED_FRAME.test(json?.type ?? "")) {
+      this.deps.ingest?.(json, taskId);
     }
   }
+  /** Test seam: exercise handleLine without an SSE stream. */
+  handleLineForTest(rawLine, taskId) {
+    this.handleLine(taskId, rawLine);
+  }
+  /** Test seam: read pendingPermByTask without exposing it publicly. */
+  pendingPermForTest(taskId) {
+    return this.pendingPermByTask.get(taskId);
+  }
 };
 
 // packages/agents/dist/interactive/claude.js
@@ -8038,70 +8447,41 @@ var ClaudeReceiptListener = class {
   }
 };
 
-// packages/agents/dist/opencode/control-source.js
-var OpencodeControlSource = class {
-  name = "opencode-control";
-  deps;
-  active = false;
-  cache = /* @__PURE__ */ new Map();
-  start(deps) {
-    this.deps = deps;
-    this.active = true;
-  }
-  stop() {
-    this.deps = void 0;
-    this.active = false;
-    this.cache.clear();
-  }
-  /** Push-only source — no fallible startup of its own. */
-  health() {
-    return { active: this.active, error: null };
-  }
-  /** Liveness floor: origin must be "scan" and must not assert needsInput. */
-  snapshot(taskId) {
-    const s = this.cache.get(taskId);
-    if (!s)
-      return void 0;
-    return { ...s, origin: "scan", state: s.state === "needsInput" ? "running" : s.state };
-  }
-  /**
-   * Feed one ControlEvent from OpencodeSseBridge into the port.
-   * Wired in squadrantd.ts as: emit = (ev) => { source.observe(ev); …existing… }
-   */
-  observe(ev) {
-    if (!this.deps)
-      return;
-    const snap = toSnapshot2(ev);
-    if (!snap)
-      return;
-    this.cache.set(snap.taskId, snap);
-    this.deps.report(snap);
-  }
-};
-function toSnapshot2(ev) {
-  const now = Date.now();
-  switch (ev.type) {
-    // A permission was answered on the bus and the turn resumed.
-    case "task.started":
-      return { taskId: ev.id, state: "running", alive: true, origin: "agent", at: now };
-    // session.idle — the turn finished. Liveness, NOT completion (anti-#2576).
-    case "task.turn.completed":
-      return { taskId: ev.id, state: "idle", alive: true, origin: "agent", at: now };
-    // permission.asked — opencode STATES it is gated. No guessing from pixels.
-    case "task.approval.requested":
-      return {
-        taskId: ev.id,
-        state: "needsInput",
-        alive: true,
-        origin: "agent",
-        at: now,
-        detail: { note: ev.question, reason: ev.kind }
-      };
-    // Terminal (task.done/blocked/cancelled) and notify-only events are ignored:
-    // terminal state comes exclusively from `squadrant crew signal`.
-    default:
-      return null;
-  }
+// packages/agents/dist/opencode/fact-adapter.js
+function createOpencodeFactAdapter(deps) {
+  return {
+    name: "opencode-sse",
+    origin: "agent",
+    translate(raw) {
+      const f = typeof raw === "object" && raw !== null ? raw : {};
+      const type = typeof f.type === "string" ? f.type : void 0;
+      if (type === void 0)
+        return [{ kind: "unknown", name: "non-object" }];
+      const p = f.properties ?? {};
+      if (type === "session.idle") {
+        return [{
+          kind: "turn.ended",
+          turnId: typeof p.sessionID === "string" ? p.sessionID : void 0
+        }];
+      }
+      if (type === "permission.asked") {
+        if (typeof p.id !== "string" || typeof p.sessionID !== "string") {
+          return [{ kind: "unknown", name: "permission.asked:incomplete" }];
+        }
+        const tool = typeof p.permission === "string" ? p.permission : "a tool";
+        const cmd = Array.isArray(p.patterns) && p.patterns.length ? `: ${p.patterns.join(" ")}` : "";
+        return [{
+          kind: "permission.requested",
+          question: `opencode requests permission to run ${tool}${cmd}`,
+          requestId: deps.nextRequestId(),
+          tool
+        }];
+      }
+      if (type === "permission.replied")
+        return [{ kind: "activity" }];
+      return [{ kind: "unknown", name: type }];
+    }
+  };
 }
 
 // packages/workspaces/dist/runtimes/cmux.js
@@ -9556,6 +9936,7 @@ function registerSenderIdentity(socketPath) {
 }
 async function sharedReceiptListener() {
   if (shared) return shared;
+  ensureSocksDir();
   const socketPath = `${CC_SOCKS_DIR}/squadrantd-${process.pid}.sock`;
   const listener = new ClaudeReceiptListener({
     socketPath,
@@ -9716,7 +10097,37 @@ function startSquadrantd(opts = {}) {
       codexAppServerSource.observe(ev);
     }
   });
-  const opencodeControlSource = new OpencodeControlSource();
+  const violationLogState = /* @__PURE__ */ new Map();
+  const VIOLATION_LOG_SUMMARY_MS = 6e4;
+  const onEventsViolation = (v2) => {
+    const key = `${v2.taskId}:${v2.code}`;
+    const prev = violationLogState.get(key);
+    if (!prev) {
+      violationLogState.set(key, { count: 1, loggedAt: Date.now() });
+      log(`[events] ${v2.code} ${v2.taskId}: ${v2.message}`);
+      return;
+    }
+    prev.count++;
+    const now = Date.now();
+    if (now - prev.loggedAt > VIOLATION_LOG_SUMMARY_MS) {
+      log(`[events] ${v2.code} ${v2.taskId}: seen ${prev.count}x since last log (latest: ${v2.message})`);
+      prev.count = 0;
+      prev.loggedAt = now;
+    }
+  };
+  const opencodeRequestIds = { n: 1 };
+  const eventsSource = createEventsSource({
+    adapters: [createOpencodeFactAdapter({ nextRequestId: () => opencodeRequestIds.n++ })],
+    emit: (ev) => {
+      const found = store.listAll().find((r) => r.id === ev.id);
+      if (!found) return;
+      void ctx.d.handle({ kind: "event", project: found.project, event: ev });
+      if (ev.type === "task.approval.requested")
+        ctx.schedulePromotion(ev.id, ev.requestId, "approval", ev.question);
+    },
+    onViolation: onEventsViolation,
+    check: { stallBudgetMs: 6e4, disagreeWindowMs: 5e3 }
+  });
   const opencodeBridge = opts.opencodeBridge ?? new OpencodeSseBridge({
     emit: (ev) => {
       const found = store.listAll().find((r) => r.id === ev.id);
@@ -9724,8 +10135,8 @@ function startSquadrantd(opts = {}) {
       void ctx.d.handle({ kind: "event", project: found.project, event: ev });
       if (ev.type === "task.approval.requested")
         ctx.schedulePromotion(ev.id, ev.requestId, "approval", ev.question);
-      opencodeControlSource.observe(ev);
     },
+    ingest: (raw, taskId) => eventsSource.ingest("opencode-sse", raw, { taskId }),
     log
   });
   const cmuxEventsBridge = opts.cmuxEventsBridge ?? new CmuxEventsBridge({
@@ -9750,11 +10161,11 @@ function startSquadrantd(opts = {}) {
   ctx.cmuxEventsBridge = cmuxEventsBridge;
   const claudePeerRegistrySource = new ClaudePeerRegistrySource({ log });
   ctx.lifecycleSources = [
+    eventsSource,
     cmuxStoreSource,
     nativeHookSource,
     codexAppServerSource,
-    claudePeerRegistrySource,
-    opencodeControlSource
+    claudePeerRegistrySource
   ];
   const tgCfg = loadConfig().telegram;
   ctx.telegramBridge = opts.telegramBridge ?? (tgCfg && !process.env.VITEST ? buildTelegramBridge(
@@ -9810,6 +10221,37 @@ ${buildCompletionProtocol(rec.id, rec.project)}`;
     }
   });
   const h = startDaemon(ctx, { ...opts, launchHeadless }, PKG_VERSION);
+  const startEventsLifecycleSource = () => {
+    let eventsTaskIndex;
+    let eventsTaskIndexAt = 0;
+    const EVENTS_TASK_INDEX_TTL_MS = 500;
+    const eventsSourceDeps = {
+      resolve: (hint) => {
+        if (!hint.taskId) return void 0;
+        const now = Date.now();
+        if (!eventsTaskIndex || now - eventsTaskIndexAt > EVENTS_TASK_INDEX_TTL_MS) {
+          eventsTaskIndex = /* @__PURE__ */ new Map();
+          for (const r of store.listAll()) {
+            if (!TERMINAL_STATES.has(r.state)) eventsTaskIndex.set(r.id, { id: r.id });
+          }
+          eventsTaskIndexAt = now;
+        }
+        const cached = eventsTaskIndex.get(hint.taskId);
+        if (cached) return cached;
+        return store.listAll().find(
+          (r) => r.id === hint.taskId && !TERMINAL_STATES.has(r.state)
+        );
+      },
+      report: () => {
+      },
+      log
+    };
+    try {
+      eventsSource.start(eventsSourceDeps);
+    } catch (e) {
+      log(`events source start failed: ${e.message}`);
+    }
+  };
   if (!process.env.VITEST) {
     const prevSnaps = /* @__PURE__ */ new Map();
     const storeDeps = {
@@ -9936,19 +10378,9 @@ ${buildCompletionProtocol(rec.id, rec.project)}`;
     } catch (e) {
       log(`claude peer registry source start failed: ${e.message}`);
     }
-    const opencodeSourceDeps = {
-      resolve: () => void 0,
-      report: () => {
-      },
-      // read-only slice: caching is internal to the source
-      log
-    };
-    try {
-      opencodeControlSource.start(opencodeSourceDeps);
-    } catch (e) {
-      log(`opencode control source start failed: ${e.message}`);
-    }
+    startEventsLifecycleSource();
   }
+  if (opts.forceStartEventsSource) startEventsLifecycleSource();
   if (!process.env.VITEST) {
     try {
       const buildMtimeMs = statSync4(SELF_PATH2).mtimeMs;
@@ -9985,7 +10417,7 @@ ${buildCompletionProtocol(rec.id, rec.project)}`;
     } catch {
     }
     try {
-      opencodeControlSource.stop();
+      eventsSource.stop();
     } catch {
     }
     return origStop(reason);