@askexenow/exe-os 0.9.372 → 0.9.374

package/dist/chunk-ANLFH23R.js

@@ -0,0 +1,261 @@
+import {
+  killIfSameProcess,
+  ownProcessStartedAt,
+  processStartedAt
+} from "./chunk-SLLLOOEI.js";
+import {
+  resolveDataDir
+} from "./chunk-ZIG7VPJV.js";
+
+// src/lib/mcp-child-registry.ts
+import path from "path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  readdirSync
+} from "fs";
+var PID_IDENTITY_TOLERANCE_MS = 2e3;
+function registryDir() {
+  return path.join(resolveDataDir(), "mcp-children");
+}
+function registryFile(sessionKey) {
+  const sanitized = sessionKey.replace(/[^A-Za-z0-9_.-]/g, "_");
+  return path.join(registryDir(), `mcp-children-${sanitized}.json`);
+}
+function defaultIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function quantizeToPsResolution(ms) {
+  return Math.floor(ms / 1e3) * 1e3;
+}
+var _sessionKey;
+function currentMcpSessionKey() {
+  if (_sessionKey === void 0) {
+    _sessionKey = `${process.pid}-${quantizeToPsResolution(ownProcessStartedAt())}`;
+  }
+  return _sessionKey;
+}
+function registerMcpChild(sessionKey, pid, command, ownerPid = process.pid, spawnedAtMs) {
+  try {
+    mkdirSync(registryDir(), { recursive: true });
+    const file = registryFile(sessionKey);
+    const ownerStartedAtMs = ownerPid === process.pid ? ownProcessStartedAt() : processStartedAt(ownerPid);
+    let record;
+    try {
+      record = JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      record = { sessionKey, owner: { pid: ownerPid, startedAtMs: null }, children: [] };
+    }
+    if (record.children.length > 0 && !(record.owner?.pid === ownerPid && sameOwnerIdentity(record.owner?.startedAtMs ?? null, ownerStartedAtMs))) {
+      const foreign = record.children.map((c) => c.pid);
+      try {
+        process.stderr.write(
+          `[mcp-child-registry] REFUSING to adopt session ${sessionKey}: the existing record belongs to owner pid ${record.owner?.pid ?? "unknown"}, not to this process (${ownerPid}). Discarding ${foreign.length} inherited child entry(ies) [${foreign.join(", ")}] rather than claiming ownership of processes we did not spawn \u2014 a record that lies about ownership is never reaped.
+`
+        );
+      } catch {
+      }
+      record.children = [];
+    }
+    record.sessionKey = sessionKey;
+    record.owner = { pid: ownerPid, startedAtMs: ownerStartedAtMs };
+    record.children = record.children.filter((c) => c.pid !== pid);
+    const spawnFallback = quantizeToPsResolution(spawnedAtMs ?? Date.now());
+    record.children.push({
+      pid,
+      startedAtMs: processStartedAt(pid) ?? spawnFallback,
+      command
+    });
+    writeFileSync(file, JSON.stringify(record));
+  } catch {
+  }
+}
+function unregisterMcpChild(sessionKey, pid) {
+  try {
+    const file = registryFile(sessionKey);
+    if (!existsSync(file)) return;
+    let record;
+    try {
+      record = JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      return;
+    }
+    record.children = record.children.filter((c) => c.pid !== pid);
+    if (record.children.length === 0) {
+      try {
+        unlinkSync(file);
+      } catch {
+      }
+      return;
+    }
+    writeFileSync(file, JSON.stringify(record));
+  } catch {
+  }
+}
+function readSessionMcpChildren(sessionKey) {
+  try {
+    const raw = readFileSync(registryFile(sessionKey), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function clearSessionMcpChildren(sessionKey) {
+  try {
+    unlinkSync(registryFile(sessionKey));
+  } catch {
+  }
+}
+async function terminateSessionMcpChildren(sessionKey, opts = {}) {
+  const result = { sessionKey, terminated: [], sigkilled: [], skipped: [] };
+  const record = readSessionMcpChildren(sessionKey);
+  if (!record) {
+    clearSessionMcpChildren(sessionKey);
+    return result;
+  }
+  const graceMs = opts.graceMs ?? 3e3;
+  const kill = opts.kill;
+  const isAlive = opts.isAlive ?? defaultIsAlive;
+  const startedAt = opts.startedAt ?? processStartedAt;
+  const sleep = opts.sleep ?? defaultSleep;
+  const log = opts.log ?? ((m) => {
+    try {
+      process.stderr.write(m + "\n");
+    } catch {
+    }
+  });
+  const sentSigterm = [];
+  for (const child of record.children) {
+    const outcome = killIfSameProcess(child.pid, child.startedAtMs, "SIGTERM", {
+      sender: "mcp-child-registry",
+      reason: `session ${sessionKey} end`,
+      kill,
+      isAlive,
+      startedAt,
+      log
+    });
+    if (outcome === "sent") {
+      result.terminated.push(child.pid);
+      sentSigterm.push(child);
+    } else {
+      result.skipped.push(child.pid);
+    }
+  }
+  if (sentSigterm.length > 0) {
+    await sleep(graceMs);
+    for (const child of sentSigterm) {
+      let alive;
+      try {
+        alive = isAlive(child.pid);
+      } catch {
+        alive = false;
+      }
+      if (!alive) continue;
+      const outcome = killIfSameProcess(child.pid, child.startedAtMs, "SIGKILL", {
+        sender: "mcp-child-registry",
+        reason: `session ${sessionKey} end (SIGKILL escalation)`,
+        kill,
+        isAlive,
+        startedAt,
+        log
+      });
+      if (outcome === "sent") {
+        result.sigkilled.push(child.pid);
+      } else if (outcome === "skipped-identity") {
+        result.skipped.push(child.pid);
+      }
+    }
+  }
+  if (result.skipped.length === 0) {
+    clearSessionMcpChildren(sessionKey);
+  } else {
+    log(
+      `[mcp-child-registry] session ${sessionKey}: retaining registry record \u2014 ${result.skipped.length} child(ren) [${result.skipped.join(", ")}] could not be identity-verified and were NOT signalled. The record is kept so a later sweep can retry.`
+    );
+  }
+  return result;
+}
+function sameOwnerIdentity(expectedMs, actualMs) {
+  if (expectedMs === null || actualMs === null) return false;
+  return Math.abs(expectedMs - actualMs) <= PID_IDENTITY_TOLERANCE_MS;
+}
+async function reapOrphanedMcpChildren(opts = {}) {
+  const results = [];
+  let files;
+  try {
+    files = readdirSync(registryDir());
+  } catch {
+    return results;
+  }
+  const isAlive = opts.isAlive ?? defaultIsAlive;
+  const startedAt = opts.startedAt ?? processStartedAt;
+  const log = opts.log ?? ((m) => {
+    try {
+      process.stderr.write(m + "\n");
+    } catch {
+    }
+  });
+  for (const file of files) {
+    if (!file.startsWith("mcp-children-") || !file.endsWith(".json")) continue;
+    try {
+      const raw = readFileSync(path.join(registryDir(), file), "utf8");
+      const record = JSON.parse(raw);
+      if (!record || typeof record.sessionKey !== "string" || !Array.isArray(record.children)) {
+        continue;
+      }
+      let alive;
+      try {
+        alive = isAlive(record.owner.pid);
+      } catch {
+        alive = false;
+      }
+      if (alive && record.owner.startedAtMs == null) {
+        const childPids = record.children.map((c) => c.pid);
+        log(
+          `[mcp-child-registry] UNVERIFIABLE session ${record.sessionKey}: owner pid ${record.owner.pid} is alive but has NO recorded start time, so it cannot be confirmed as the original owner. Refusing to terminate its ${childPids.length} child(ren) [${childPids.join(", ")}] \u2014 signalling on unverified identity is how a recycled PID gets an innocent process killed. These children may be leaked; they will be reaped once that pid is gone.`
+        );
+        try {
+          opts.onUnverifiable?.({ sessionKey: record.sessionKey, ownerPid: record.owner.pid, childPids });
+        } catch {
+        }
+        continue;
+      }
+      let recycled = false;
+      if (alive && record.owner.startedAtMs != null) {
+        let actual;
+        try {
+          actual = startedAt(record.owner.pid);
+        } catch {
+          actual = null;
+        }
+        recycled = !sameOwnerIdentity(record.owner.startedAtMs, actual);
+      }
+      if (alive && !recycled) continue;
+      const result = await terminateSessionMcpChildren(record.sessionKey, opts);
+      results.push(result);
+    } catch {
+    }
+  }
+  return results;
+}
+
+export {
+  currentMcpSessionKey,
+  registerMcpChild,
+  unregisterMcpChild,
+  readSessionMcpChildren,
+  clearSessionMcpChildren,
+  terminateSessionMcpChildren,
+  reapOrphanedMcpChildren
+};

package/dist/{chunk-QLA3RTH4.js → chunk-AWWKRZMB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SSC7EKY2.js";
 import {
   inventoryLocalSecretResidue
-} from "./chunk-E5HAY3DQ.js";
+} from "./chunk-HDLAB7W3.js";
 import {
   CC_NATIVE_ONLY_CUTOFF,
   compareSemver,
@@ -12,22 +12,22 @@ import {
 import {
   readMcpHttpEvents,
   summarizeMcpTransport
-} from "./chunk-YYA5LXCT.js";
+} from "./chunk-FNEZ4BWT.js";
 import {
   mcpHttpPort
-} from "./chunk-LDL3S7AC.js";
+} from "./chunk-NKETJCB5.js";
 import {
   inspectKeyCustodySync
 } from "./chunk-HPXFKUGU.js";
 import {
   checkSingleGotrueInstance
-} from "./chunk-TCTED52S.js";
+} from "./chunk-FTZET5YX.js";
 import {
   SYSTEMD_DAEMON_UNIT
 } from "./chunk-A7JYF4RG.js";
 import {
   EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/bin/exe-healthcheck.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";

package/dist/{chunk-ERVQTR7P.js → chunk-BBSIEYF5.js}

@@ -1,15 +1,15 @@
 import {
   PLATFORM_PROCEDURE_TITLES
-} from "./chunk-THIJIOE2.js";
+} from "./chunk-PY3FOMRN.js";
 import {
   isGhostBehaviorRow
-} from "./chunk-MBNIJXKI.js";
+} from "./chunk-WMEYJT4R.js";
 import {
   getClient,
   getIdentity,
   listIdentities,
   updateIdentity
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-HSGBZSCA.js";
@@ -126,13 +126,27 @@ function buildImportedRosterEntries(roster, timestamp) {
     ...entry.templateVersion != null ? { templateVersion: entry.templateVersion } : {}
   }));
 }
+var behaviorKey = (agentId, content) => `${agentId}::${content}`;
 async function insertBehaviors(behaviors, timestamp) {
   const client = getClient();
+  const seen = /* @__PURE__ */ new Set();
+  const existing = await client.execute({
+    sql: "SELECT agent_id, content FROM behaviors WHERE active = 1",
+    args: []
+  });
+  for (const row of existing.rows) {
+    seen.add(behaviorKey(String(row.agent_id), String(row.content)));
+  }
   let inserted = 0;
   for (const behavior of behaviors) {
     if (isGhostBehaviorRow({ id: "import", content: behavior.content, agent_id: behavior.agent_id })) {
       continue;
     }
+    const key = behaviorKey(behavior.agent_id, behavior.content);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
     await client.execute({
       sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
             VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,

package/dist/{chunk-IPMUWYRQ.js → chunk-BJ7AVSY6.js}

@@ -1,9 +1,9 @@
 import {
   sendMessage
-} from "./chunk-7WQRFSZI.js";
+} from "./chunk-SL6KQYDU.js";
 import {
   getActiveAgent
-} from "./chunk-KYFFVTGO.js";
+} from "./chunk-55BEFF4V.js";
 
 // src/mcp/tools/send-message.ts
 import { z } from "zod";

package/dist/{chunk-HV6Y6F4X.js → chunk-C2L622QJ.js}

@@ -130,12 +130,65 @@ function basename(tok) {
 function isGitProgram(tok) {
   return tok === "git" || /(?:^|\/)git$/.test(tok);
 }
+function isGhProgram(tok) {
+  return tok === "gh" || /(?:^|\/)gh$/.test(tok);
+}
+function ghHasDeleteMethod(tokens) {
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if ((t === "-X" || t === "--method") && (tokens[i + 1] ?? "").toUpperCase() === "DELETE") return true;
+    const attached = /^(?:-X|--method)=(.+)$/.exec(t);
+    if (attached && attached[1].toUpperCase() === "DELETE") return true;
+    const combined = /^-X(.+)$/.exec(t);
+    if (combined && combined[1].toUpperCase() === "DELETE") return true;
+  }
+  return false;
+}
+function endpointRefPath(tok) {
+  const cut = tok.search(/[?#]/);
+  return cut >= 0 ? tok.slice(0, cut) : tok;
+}
+function classifyGhSegment(tokens) {
+  const ghIdx = tokens.findIndex(isGhProgram);
+  if (ghIdx === -1) return "none";
+  const hasApi = tokens.slice(ghIdx + 1).includes("api");
+  if (!hasApi) return "none";
+  if (!ghHasDeleteMethod(tokens)) return "none";
+  const endpoint = tokens.find(
+    (t, i) => i > ghIdx && !t.startsWith("-") && // not a flag / attached flag (-X, --method=..., --field=...)
+    !/^[A-Za-z_][\w.-]*=/.test(t) && // not a key=value field/header value
+    /git\/refs\//.test(endpointRefPath(t))
+  );
+  if (endpoint === void 0) return "none";
+  const refPath = endpointRefPath(endpoint);
+  if (/git\/refs\/tags\//.test(refPath)) return "tag";
+  return "block";
+}
 function isShellProgram(tok) {
   return SHELLS.has(basename(tok));
 }
 function isDashC(tok) {
   return /^-[a-z]*c[a-z]*$/i.test(tok) && tok.includes("c");
 }
+var SHELL_VALUE_OPTS = /* @__PURE__ */ new Set(["-o", "+o", "-O", "+O", "--rcfile", "--init-file"]);
+function shellDashCScriptIndex(tokens, i) {
+  if (!isShellProgram(tokens[i])) return -1;
+  let j = i + 1;
+  while (j < tokens.length) {
+    const t = tokens[j];
+    if (isDashC(t)) return j + 1 < tokens.length ? j + 1 : -1;
+    if (SHELL_VALUE_OPTS.has(t)) {
+      j += 2;
+      continue;
+    }
+    if (t.startsWith("-")) {
+      j++;
+      continue;
+    }
+    return -1;
+  }
+  return -1;
+}
 function isLeadingAssignment(tok) {
   return /^[A-Za-z_][A-Za-z0-9_]*=/.test(tok);
 }
@@ -240,8 +293,9 @@ function containsDestructiveGitCandidate(command, depth = 0) {
   if (depth > 3) return true;
   const { tokens } = tokenizeShell(command);
   for (let i = 0; i < tokens.length; i++) {
-    if (isShellProgram(tokens[i]) && tokens[i + 1] && isDashC(tokens[i + 1])) {
-      const script = tokens[i + 2];
+    const si = shellDashCScriptIndex(tokens, i);
+    if (si >= 0) {
+      const script = tokens[si];
       if (script && containsDestructiveGitCandidate(script, depth + 1)) return true;
     }
   }
@@ -259,6 +313,24 @@ function containsDestructiveGitCandidate(command, depth = 0) {
   if (tokens.some((t) => /^alias\./.test(t))) return true;
   return hasDestructiveVerbTokens(tokens);
 }
+function ghApiRefDeleteVerdict(command, depth = 0) {
+  if (depth > 3) return "block";
+  const { tokens } = tokenizeShell(command);
+  for (let i = 0; i < tokens.length; i++) {
+    const si = shellDashCScriptIndex(tokens, i);
+    if (si >= 0) {
+      const script = tokens[si];
+      if (script && ghApiRefDeleteVerdict(script, depth + 1) === "block") return "block";
+    }
+  }
+  let sawTag = false;
+  for (const seg of splitShellSegments(command)) {
+    const v = classifyGhSegment(tokenizeShell(seg).tokens);
+    if (v === "block") return "block";
+    if (v === "tag") sawTag = true;
+  }
+  return sawTag ? "tag" : "none";
+}
 var PUSH_VALUE_OPTS = /* @__PURE__ */ new Set(["-o", "--push-option", "--repo", "--receive-pack", "--exec", "--recurse-submodules"]);
 var REBASE_VALUE_OPTS = /* @__PURE__ */ new Set(["--onto", "-s", "--strategy", "-X", "--strategy-option", "--exec", "-x", "--whitespace"]);
 function parseSingleGitCommand(tokens) {
@@ -572,7 +644,7 @@ function getCurrentBranch(cwd) {
 }
 function hasEmergencyOverride(command, env = process.env) {
   if (env[MAIN_GUARD_OVERRIDE_ENV] === "1") return true;
-  return new RegExp(String.raw`^\s*${MAIN_GUARD_OVERRIDE_ENV}=1\s+git\b`).test(command);
+  return new RegExp(String.raw`^\s*${MAIN_GUARD_OVERRIDE_ENV}=1\s+(?:git|gh)\b`).test(command);
 }
 function normalizeCleanGit(tokens) {
   const first = tokens[0];
@@ -586,6 +658,9 @@ function evaluateMainGuard(command, opts = {}) {
   const env = opts.env ?? process.env;
   const cwd = opts.cwd ?? process.cwd();
   if (hasEmergencyOverride(command, env)) return { block: false, overridden: true };
+  if (ghApiRefDeleteVerdict(command) === "block") {
+    return { block: true, message: formatGhApiRefDeleteBlockMessage() };
+  }
   if (!containsDestructiveGitCandidate(command)) return { block: false };
   const { tokens, hasShellControl } = tokenizeShell(command);
   if (hasShellControl) {
@@ -661,6 +736,14 @@ SAFE ALTERNATIVES:
   \u2022 Resetting a NON-${info.branch} branch onto its own ancestor is allowed \u2014 check that branch out first (git checkout -B <branch> <sha>); this guard only fires when ${info.branch} itself moves.
 ${OVERRIDE_LINE}`;
 }
+function formatGhApiRefDeleteBlockMessage() {
+  return `\u{1F6AB} BLOCKED: deleting a remote ref via \`gh api -X DELETE .../git/refs/...\`.
+WHY: this is the same destructive operation as \`git push --delete <branch>\`, which this guard gates. Routing the deletion through the REST API does not make it safe \u2014 a remote branch ref is being destroyed.
+WHAT TO DO:
+  \u2022 Deleting a TAG is fine \u2014 target refs/tags explicitly: gh api -X DELETE .../git/refs/tags/<tag>
+  \u2022 If you truly intend to delete a remote BRANCH, do it deliberately and auditably with the documented override.
+${OVERRIDE_LINE}`;
+}
 function formatForcePushBlockMessage(verb = "force/delete push to main") {
   return `\u{1F6AB} BLOCKED: ${verb} would overwrite SHARED history on origin \u2014 it can silently discard commits other people (and other agents) pushed.
 WHY: --force / --force-with-lease / --mirror / +refspec / --delete rewrites the remote branch everyone builds on (bug 6aaea78f).
@@ -696,8 +779,10 @@ export {
   MAIN_GUARD_OVERRIDE_ENV,
   tokenizeShell,
   isGitProgram,
+  isGhProgram,
   splitShellSegments,
   containsDestructiveGitCandidate,
+  ghApiRefDeleteVerdict,
   parseSingleGitCommand,
   resolveRepoState,
   isResolvableRefName,
@@ -710,6 +795,7 @@ export {
   hasEmergencyOverride,
   evaluateMainGuard,
   formatMainAheadBlockMessage,
+  formatGhApiRefDeleteBlockMessage,
   formatForcePushBlockMessage,
   formatUnprovableDeleteBlockMessage,
   formatUnverifiableBlockMessage,

package/dist/{chunk-TX3Q2GIL.js → chunk-C5HUMAA7.js}

@@ -65,6 +65,28 @@ function readDeployStalenessAlert(alertPath = deployStalenessAlertPath()) {
     return null;
   }
 }
+function stackLockCandidatePaths() {
+  const override = process.env.EXE_STACK_LOCK_FILE;
+  if (override) return [override];
+  return [
+    path.join("/opt/exe-stack", ".exe-stack-lock.json"),
+    path.join(process.cwd(), ".exe-stack-lock.json")
+  ];
+}
+function readStackLockSnapshot(candidates = stackLockCandidatePaths()) {
+  for (const candidate of candidates) {
+    try {
+      if (!existsSync(candidate)) continue;
+      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+      if (parsed && typeof parsed === "object") return parsed;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveDeployStalenessAlert(alertPath = deployStalenessAlertPath(), candidates = stackLockCandidatePaths(), now = () => /* @__PURE__ */ new Date()) {
+  return readDeployStalenessAlert(alertPath) ?? evaluateDeployStaleness(readStackLockSnapshot(candidates), now);
+}
 function buildDeployStalenessBanner(alert) {
   if (!alert) return [];
   const lines = [];
@@ -90,8 +112,9 @@ function buildDeployStalenessBanner(alert) {
 
 export {
   evaluateDeployStaleness,
+  deployStalenessAlertPath,
   writeDeployStalenessAlert,
   clearDeployStalenessAlert,
-  readDeployStalenessAlert,
+  resolveDeployStalenessAlert,
   buildDeployStalenessBanner
 };

package/dist/{chunk-QTYJPWJN.js → chunk-CBCGDEJA.js}

@@ -6,20 +6,20 @@ import {
   queryTaskRows,
   resolveExeSession,
   sendIntercom
-} from "./chunk-XHYHX6F7.js";
+} from "./chunk-AKLQSC6W.js";
 import {
   getTransport
-} from "./chunk-UXLO7VHX.js";
+} from "./chunk-VI4ATC6I.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-E2WEFZOR.js";
+} from "./chunk-W75GTHR3.js";
 import {
   releaseDispatchClaim,
   tryAcquireDispatchClaim
 } from "./chunk-AJIXH5JF.js";
 import {
   getAgentRuntime
-} from "./chunk-XTWHNLGD.js";
+} from "./chunk-GZOG2MAX.js";
 import {
   getSessionKey
 } from "./chunk-CVYC6DUW.js";
@@ -27,7 +27,7 @@ import {
   isCoordinatorName,
   isMultiInstance,
   shouldAutoInstance
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 
 // src/lib/tasks-notify.ts
 var VERIFY_DELAY_MS = 1e4;
@@ -89,7 +89,7 @@ async function dispatchTaskToEmployee(input) {
   let crossProject = false;
   if (input.projectName) {
     try {
-      const { assertSessionScope } = await import("./session-scope-LG2J4EMQ.js");
+      const { assertSessionScope } = await import("./session-scope-KRWE54C4.js");
       const check = assertSessionScope("dispatch_task", input.projectName);
       if (check.reason === "cross_session_denied") {
         crossProject = true;
@@ -227,7 +227,7 @@ async function dispatchTaskToEmployee(input) {
         return { dispatched: "skipped", session: sessionName, crossProject };
       }
       const result = sendIntercom(sessionName, { force: true });
-      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" || result === "sent" ? "sent_unverified" : "session_dead";
       process.stderr.write(
         `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result})
 `

package/dist/{chunk-XXSNLM6R.js → chunk-DB55JZHU.js}

@@ -1,7 +1,7 @@
 import {
   checkLicense,
   loadLicense
-} from "./chunk-DKBPCOU4.js";
+} from "./chunk-L6RXG36J.js";
 
 // src/lib/license-gate.ts
 var _cachedLicense = null;