@mrrlin-dev/mcp 0.4.41 → 0.4.43

package/dist/bin.cjs

@@ -3008,7 +3008,7 @@ var require_range = __commonJS({
       parseRange(range) {
         const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
         const memoKey = memoOpts + ":" + range;
-        const cached2 = cache.get(memoKey);
+        const cached2 = cache2.get(memoKey);
         if (cached2) {
           return cached2;
         }
@@ -3042,7 +3042,7 @@ var require_range = __commonJS({
           rangeMap.delete("");
         }
         const result = [...rangeMap.values()];
-        cache.set(memoKey, result);
+        cache2.set(memoKey, result);
         return result;
       }
       intersects(range, options) {
@@ -3081,7 +3081,7 @@ var require_range = __commonJS({
     };
     module2.exports = Range;
     var LRU = require_lrucache();
-    var cache = new LRU();
+    var cache2 = new LRU();
     var parseOptions = require_parse_options();
     var Comparator = require_comparator();
     var debug = require_debug();
@@ -20644,11 +20644,11 @@ var require_dist = __commonJS({
 });
 
 // src/bin.ts
-var import_node_path31 = __toESM(require("node:path"), 1);
+var import_node_path34 = __toESM(require("node:path"), 1);
 var import_node_child_process18 = require("node:child_process");
-var import_node_fs19 = require("node:fs");
-var import_node_os15 = require("node:os");
-var import_node_path32 = __toESM(require("node:path"), 1);
+var import_node_fs22 = require("node:fs");
+var import_node_os16 = require("node:os");
+var import_node_path35 = __toESM(require("node:path"), 1);
 
 // src/install-codex.ts
 var import_promises = __toESM(require("node:fs/promises"), 1);
@@ -21554,12 +21554,12 @@ async function verifyProviderReadiness(provider, run3, opts = {}) {
 }
 
 // src/director-bridge.ts
-var import_node_fs17 = __toESM(require("node:fs"), 1);
+var import_node_fs20 = __toESM(require("node:fs"), 1);
 var import_node_http = __toESM(require("node:http"), 1);
-var import_node_os11 = __toESM(require("node:os"), 1);
-var import_node_path24 = __toESM(require("node:path"), 1);
+var import_node_os12 = __toESM(require("node:os"), 1);
+var import_node_path27 = __toESM(require("node:path"), 1);
 var import_node_child_process15 = require("node:child_process");
-var import_node_crypto10 = __toESM(require("node:crypto"), 1);
+var import_node_crypto11 = __toESM(require("node:crypto"), 1);
 
 // src/turn-replay-buffer.ts
 var DEFAULT_MAX_EVENTS = 2e3;
@@ -36816,6 +36816,17 @@ var ARTIFACT_CHECKS = {
   structured_data: null,
   message: { verifier: "status" }
 };
+var ARTIFACT_DESTINATIONS = {
+  document: "wiki",
+  page: "git",
+  file_set: null,
+  code_change: "git",
+  structured_data: null,
+  message: null
+};
+function resolveKindCapability(kind) {
+  return ARTIFACT_DESTINATIONS[kind];
+}
 
 // ../../packages/schemas/dist/operationIds.js
 var openApiOperationIds = {
@@ -36957,7 +36968,11 @@ var openApiOperationIds = {
   upsertCapabilityRoute: "upsertCapabilityRoute",
   resolveCapabilityRoute: "resolveCapabilityRoute",
   overrideCapabilityToolClass: "overrideCapabilityToolClass",
-  listCapabilityUses: "listCapabilityUses"
+  listCapabilityUses: "listCapabilityUses",
+  confirmFirstWrite: "confirmFirstWrite",
+  resolveArtifactKindRoute: "resolveArtifactKindRoute",
+  resolveDeliveryForArtifactKind: "resolveDeliveryForArtifactKind",
+  recordCapabilityUse: "recordCapabilityUse"
 };
 
 // ../../packages/schemas/dist/session.js
@@ -37206,7 +37221,7 @@ var mrrlinAsyncJobRequeueSchema = external_exports.object({
 });
 
 // ../../packages/schemas/dist/telemetry.js
-var LOG_PROJECTION_KINDS = ["tool_use", "tool_result", "turn_lifecycle", "plumbing"];
+var LOG_PROJECTION_KINDS = ["tool_use", "tool_result", "turn_lifecycle", "plumbing", "gate_call"];
 var PLUMBING_KINDS = [
   "socket_close",
   "ready",
@@ -37272,14 +37287,60 @@ var telemetryRowSchema = external_exports.object({
   projectionFailures: external_exports.number(),
   gateMarker: external_exports.enum(GATE_MARKERS)
 });
+var GATE_KINDS = ["spec", "code", "deliverable"];
+var GATE_CALL_ROLES = ["head", "arbiter", "reviser", "findings"];
+var gateCallRecordSchema = external_exports.object({
+  day: external_exports.string(),
+  gate: external_exports.enum(GATE_KINDS),
+  /**
+   * The gate's own round, 1-based. Zero is legal and means "outside the loop": spec-gate.ts makes
+   * one reviser call BEFORE runConsensus is ever entered, and labelling it round 1 would put a
+   * pre-loop call inside a round that had not started.
+   */
+  round: external_exports.number(),
+  role: external_exports.enum(GATE_CALL_ROLES),
+  /** The persona file driving the call, or null for a role that loads none (the revisers). */
+  persona: external_exports.string().nullable(),
+  /** Null where the call site minted no seat and therefore genuinely does not know — a guessed
+   *  provider on a cost record is worse than an absent one. */
+  provider: external_exports.string().nullable(),
+  agentId: external_exports.string().nullable(),
+  inputTokens: external_exports.number().nullable(),
+  cachedInputTokens: external_exports.number().nullable(),
+  cacheWriteInputTokens: external_exports.number().nullable(),
+  outputTokens: external_exports.number().nullable(),
+  durationMs: external_exports.number()
+});
 var telemetryBatchSchema = external_exports.object({
   day: external_exports.string(),
   bridgeVersion: external_exports.string(),
+  /**
+   * Which installation produced this batch. OPTIONAL on the wire on purpose: a bridge that has not
+   * restarted after deploy still posts batches, and rejecting them would turn a rollout window into
+   * data loss. The API resolves a missing value to the literal installation `legacy`, which is
+   * exactly today's behaviour — one shared slot — so nothing regresses while everything that does
+   * send an id gains its own.
+   */
+  installationId: external_exports.string().optional(),
   knownCrashCount: external_exports.number(),
   // pairs still lacking .processed-* after this run completes; a project that never uploads at
   // all cannot report its own gap this way — silence is not coverage.
   unprocessedPartitions: external_exports.array(external_exports.object({ projectSlug: external_exports.string(), day: external_exports.string() })),
-  rows: external_exports.array(telemetryRowSchema)
+  rows: external_exports.array(telemetryRowSchema),
+  /**
+   * Consensus-gate provider calls for this day. Optional, exactly like `installationId` above and
+   * for the same reason: a bridge that makes no gate call, and every uploader built before this
+   * field existed, must keep producing a valid batch — a rollout window is not allowed to become
+   * data loss.
+   *
+   * `.optional()` rather than `.default([])`, which was tried first. A Zod default splits the
+   * schema's input type from its output type, so the parsed batch would carry a REQUIRED
+   * `gateCalls` while producers do not — and every construction site (the uploader, the store
+   * tests, the ingest tests) would then have to name a field it has no opinion about. An absent
+   * array and an empty one mean the same thing to every reader here, so the split buys nothing and
+   * costs a trap.
+   */
+  gateCalls: external_exports.array(gateCallRecordSchema).optional()
 });
 var evidenceStepSchema = external_exports.object({
   toolName: external_exports.string(),
@@ -37487,6 +37548,18 @@ var mrrlinDeclaredOutcomeSchema = mrrlinDeclaredOutcomeShapeSchema.superRefine((
       message: `requires spans more than one verifier, so no receipt can ever satisfy it (${spread}). Declare the outcome rather than the steps that produced it; if two things must genuinely exist and neither is a means to the other, split them into linked tasks.`
     });
   }
+  const distinctCapabilities = new Set(value.requires.map((kind) => resolveKindCapability(kind)).filter((capability) => capability !== null));
+  if (distinctCapabilities.size > 1) {
+    const spread = value.requires.map((kind) => {
+      const capability = resolveKindCapability(kind);
+      return capability === null ? `${kind} has no destination` : `${kind} routes to ${capability}`;
+    }).join(", ");
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["requires"],
+      message: `requires spans more than one capability, so no single delivery can satisfy it (${spread}). Split into linked tasks, one per destination.`
+    });
+  }
   const hasVerifiableKind = value.requires.some((kind) => ARTIFACT_CHECKS[kind] !== null);
   const hasUnverifiableKind = value.requires.some((kind) => ARTIFACT_CHECKS[kind] === null);
   if (value.verification === "human_tap" && hasVerifiableKind) {
@@ -37614,6 +37687,13 @@ var mrrlinRunBlockingReasonCodeSchema = external_exports.enum([
   // with a task-content block; before it existed such a failure fell through to `unknown` and was
   // handed off to the operator as though the Director had judged the task.
   "provider_limit_exhausted",
+  // Крок 3, task 8.1: the dispatch pre-flight's own refusal — the task's declared outcome requires
+  // an artifact kind with no capability route at all (client-side, resolveKindCapability) or no
+  // configured route in this project (server-side, resolveArtifactKindRoute). Distinct from
+  // `task_blocked` (which is about blocker TASKS, not this run's own delivery destination): a task
+  // whose blockers clear can start; a task whose required kind cannot route needs an operator to
+  // configure the missing route before any retry would succeed.
+  "capability_not_routed",
   "unknown"
 ]);
 var mrrlinExecutionArtifactKindSchema = external_exports.enum([
@@ -37694,6 +37774,13 @@ var mrrlinStopReasonSchema = external_exports.enum([
   "consensus_disabled_spec_not_ready",
   "spec_approval_pending",
   "awaiting_handoff",
+  // Крок 3 (delivery-as-capability-call), task 3.1: the parked reason for an open capability
+  // question (origin: "capability"), the same shape as awaiting_clarification's own open gate
+  // question (origin: "gate") one line above -- caught by the whole-change gate (task 9.3), not
+  // task 3.1 itself: this schema and mrrlinSchedulerParkedReasonSchema are siblings apps/web's
+  // autopilotQueue.ts assumes stay in lockstep (every parked reason not explicitly remapped is
+  // used as a stop reason directly), and no per-package typecheck in this change ever ran apps/web.
+  "awaiting_capability_decision",
   "assigned_to_other",
   "backlog",
   "attempts_exhausted",
@@ -38877,7 +38964,11 @@ var mrrlinSchedulerParkedReasonSchema = external_exports.enum([
   "awaiting_handoff",
   "awaiting_clarification",
   "spec_awaiting_approval",
-  "blocked_by_active"
+  "blocked_by_active",
+  // Derived, not stored (design.md, "Parking is derived"): an open `question` inbox item with
+  // `origin === "capability"` yields this reason, exactly as an `origin === "gate"` one already
+  // yields `awaiting_clarification`. No column, and nobody but the derivation may set it.
+  "awaiting_capability_decision"
 ]);
 var mrrlinSchedulerParkedTaskSchema = external_exports.object({
   task: mrrlinTaskSchema,
@@ -39216,6 +39307,16 @@ var capabilityRouteResponseSchema = external_exports.object({ data: CapabilityRo
 var capabilityRouteListResponseSchema = external_exports.object({ data: external_exports.array(CapabilityRouteSchema) });
 var capabilityToolClassResponseSchema = external_exports.object({ data: CapabilityToolClassSchema });
 var capabilityUseListResponseSchema = external_exports.object({ data: external_exports.array(CapabilityUseSchema) });
+var capabilityUseResponseSchema = external_exports.object({ data: CapabilityUseSchema.nullable() });
+var capabilityUseCreateSchema = external_exports.object({
+  serverId: capabilityServerIdSchema,
+  toolName: capabilityToolNameSchema,
+  taskId: mrrlinTaskIdSchema.nullable(),
+  outcome: capabilityUseOutcomeSchema
+});
+var deliveryResolutionResponseSchema = external_exports.object({
+  data: external_exports.object({ route: CapabilityRouteSchema, verdict: CapabilityGateVerdictSchema })
+});
 
 // ../../packages/agent-client/dist/providers/codex/render-context-bundle.js
 var DEFAULT_SPEC_BUDGET_CHARS = 6e3;
@@ -40044,6 +40145,68 @@ function resolveProvider(env, persisted) {
 
 // ../../packages/agent-client/dist/providers/codex/exec.js
 var import_node_child_process5 = require("node:child_process");
+
+// ../../packages/agent-client/dist/exec-usage.js
+function readCount2(source, ...keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+  }
+  return null;
+}
+function fromBlock(block) {
+  const usage = {
+    inputTokens: readCount2(block, "input_tokens", "inputTokens"),
+    cachedInputTokens: readCount2(block, "cached_input_tokens", "cache_read_input_tokens", "cachedInputTokens"),
+    cacheWriteInputTokens: readCount2(block, "cache_write_input_tokens", "cache_creation_input_tokens", "cacheWriteInputTokens"),
+    outputTokens: readCount2(block, "output_tokens", "outputTokens")
+  };
+  const measuredNothing = usage.inputTokens === null && usage.cachedInputTokens === null && usage.cacheWriteInputTokens === null && usage.outputTokens === null;
+  return measuredNothing ? null : usage;
+}
+function extractCodexExecUsage(stdout) {
+  let last = null;
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line[0] !== "{")
+      continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof event !== "object" || event === null)
+      continue;
+    const usage = event.usage;
+    if (typeof usage !== "object" || usage === null)
+      continue;
+    const parsed = fromBlock(usage);
+    if (parsed !== null)
+      last = parsed;
+  }
+  return last;
+}
+function extractClaudeExecUsage(parsed) {
+  if (!Array.isArray(parsed))
+    return null;
+  for (let i = parsed.length - 1; i >= 0; i -= 1) {
+    const element = parsed[i];
+    if (typeof element !== "object" || element === null)
+      continue;
+    const record2 = element;
+    if (record2.type !== "result")
+      continue;
+    const usage = record2.usage;
+    if (typeof usage !== "object" || usage === null)
+      return null;
+    return fromBlock(usage);
+  }
+  return null;
+}
+
+// ../../packages/agent-client/dist/providers/codex/exec.js
 function extractFinalMessage(stdout) {
   let last = null;
   for (const rawLine of stdout.split(/\r?\n/)) {
@@ -40164,7 +40327,7 @@ ${input.prompt}` : input.prompt;
         finish({ ok: false, error: "codex exec produced no parseable assistant message" });
         return;
       }
-      finish({ ok: true, text });
+      finish({ ok: true, text, usage: extractCodexExecUsage(stdout) });
     });
   });
 }
@@ -40269,7 +40432,7 @@ function extractOneShotResult(stdout) {
   if (typeof resultEvent.result !== "string") {
     return { ok: false, error: "claude exec's 'result' event had no string result field" };
   }
-  return { ok: true, text: resultEvent.result };
+  return { ok: true, text: resultEvent.result, usage: extractClaudeExecUsage(parsed) };
 }
 function errMessage2(err) {
   return err instanceof Error ? err.message : String(err);
@@ -40443,6 +40606,12 @@ function createAgentTokenProvider(opts) {
 }
 
 // ../../packages/client/dist/index.js
+var CAPABILITY_ROUTE_RESOLUTION_REASON_BY_CODE = {
+  NO_ROUTE: "no_route",
+  NO_GRANT: "no_grant",
+  PROJECT_MISMATCH: "project_mismatch",
+  AMBIGUOUS_ROUTE: "ambiguous_route"
+};
 function appendQuery(url2, params) {
   const search = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
@@ -41072,6 +41241,52 @@ function createMrrlinClient(config2) {
       const body = await request(`${projectPath(projectSlug)}/capability-grants/${encodeURIComponent(serverId)}`, { method: "DELETE" });
       return capabilityGrantResponseSchema.parse(body).data;
     },
+    async confirmFirstWrite(projectSlug, serverId) {
+      try {
+        const body = await request(`${projectPath(projectSlug)}/capability-grants/${encodeURIComponent(serverId)}/first-write-confirmation`, { method: "POST" });
+        return capabilityGrantResponseSchema.parse(body).data;
+      } catch (error51) {
+        if (error51 instanceof MrrlinApiError && error51.code === "NO_GRANT")
+          return null;
+        throw error51;
+      }
+    },
+    async resolveArtifactKindRoute(projectSlug, artifactKind, taskProjectSlug) {
+      try {
+        const body = await request(`${projectPath(projectSlug)}/artifact-kinds/${encodeURIComponent(artifactKind)}/resolution?taskProjectSlug=${encodeURIComponent(taskProjectSlug)}`, { method: "POST" });
+        return { ok: true, route: capabilityRouteResponseSchema.parse(body).data };
+      } catch (error51) {
+        if (error51 instanceof MrrlinApiError) {
+          const reason = CAPABILITY_ROUTE_RESOLUTION_REASON_BY_CODE[error51.code];
+          if (reason)
+            return { ok: false, reason, message: error51.message };
+        }
+        throw error51;
+      }
+    },
+    async resolveDeliveryForArtifactKind(projectSlug, artifactKind, taskProjectSlug, taskId) {
+      try {
+        const url2 = appendQuery(`${projectPath(projectSlug)}/artifact-kinds/${encodeURIComponent(artifactKind)}/delivery-resolution`, { taskProjectSlug, taskId });
+        const body = await request(url2, { method: "POST" });
+        const { route, verdict } = deliveryResolutionResponseSchema.parse(body).data;
+        return { ok: true, route, verdict };
+      } catch (error51) {
+        if (error51 instanceof MrrlinApiError) {
+          const reason = CAPABILITY_ROUTE_RESOLUTION_REASON_BY_CODE[error51.code];
+          if (reason)
+            return { ok: false, reason, message: error51.message };
+        }
+        throw error51;
+      }
+    },
+    async recordCapabilityUse(projectSlug, input) {
+      const body = await request(`${projectPath(projectSlug)}/capability-uses`, {
+        body: JSON.stringify(input),
+        headers: { "content-type": "application/json" },
+        method: "POST"
+      });
+      return capabilityUseResponseSchema.parse(body).data;
+    },
     async listInboxItems(projectSlug, filters = {}) {
       const url2 = appendQuery(`${projectPath(projectSlug)}/inbox`, {
         groupId: filters.groupId,
@@ -42080,7 +42295,7 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.4.41";
+var PKG_VERSION = "0.4.43";
 
 // src/api-base-url-migrate.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
@@ -42983,14 +43198,37 @@ async function foldClosedDays(stateDir, today) {
 
 // src/telemetry/daily-uploader.ts
 var import_promises6 = require("node:fs/promises");
-var import_node_path12 = require("node:path");
+var import_node_path15 = require("node:path");
 
 // src/consensus/wiring.ts
 var import_node_crypto4 = __toESM(require("node:crypto"), 1);
-var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 
+// src/consensus/gate-usage-log.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path11 = require("node:path");
+function recordGateCall(stateDir, projectSlug, record2) {
+  try {
+    const dir = (0, import_node_path11.join)(stateDir, "telemetry");
+    (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs5.appendFileSync)((0, import_node_path11.join)(dir, gateFileName(projectSlug, record2.day)), `${JSON.stringify(record2)}
+`, "utf8");
+  } catch {
+  }
+}
+var SAFE_SLUG = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function gateFileName(projectSlug, day) {
+  if (!SAFE_SLUG.test(projectSlug)) {
+    throw new Error(`refusing to build a telemetry partition name from an unsafe project slug: ${JSON.stringify(projectSlug)}`);
+  }
+  return `gate-${projectSlug}-${day}.jsonl`;
+}
+function telemetryDay(now = /* @__PURE__ */ new Date()) {
+  return now.toISOString().slice(0, 10);
+}
+
 // src/consensus/verdict.ts
 var CATEGORIES = [
   "correctness",
@@ -43840,6 +44078,16 @@ ${issuesBlock}`,
   }
 }
 
+// src/consensus/sterile-cwd.ts
+var import_node_fs6 = require("node:fs");
+var import_node_os6 = require("node:os");
+var import_node_path12 = require("node:path");
+var sterileDir = null;
+function sterileCwd() {
+  sterileDir ??= (0, import_node_fs6.mkdtempSync)((0, import_node_path12.join)((0, import_node_os6.tmpdir)(), "mrrlin-gate-"));
+  return sterileDir;
+}
+
 // src/consensus/code-gate-git.ts
 var import_node_child_process8 = require("node:child_process");
 var DIFF_MAX_BYTES = 2e5;
@@ -44072,15 +44320,15 @@ ${res.stdout}${res.stderr}`);
 var import_meta2 = {};
 function getPersonasDir() {
   if (typeof __dirname !== "undefined") {
-    return import_node_path11.default.join(__dirname, "consensus", "personas");
+    return import_node_path13.default.join(__dirname, "consensus", "personas");
   }
-  return import_node_path11.default.join(import_node_path11.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url)), "personas");
+  return import_node_path13.default.join(import_node_path13.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url)), "personas");
 }
 var personaCache = /* @__PURE__ */ new Map();
 function loadPersona(name) {
   const cached2 = personaCache.get(name);
   if (cached2 !== void 0) return cached2;
-  const content = import_node_fs5.default.readFileSync(import_node_path11.default.join(getPersonasDir(), `${name}.md`), "utf8");
+  const content = import_node_fs7.default.readFileSync(import_node_path13.default.join(getPersonasDir(), `${name}.md`), "utf8");
   personaCache.set(name, content);
   return content;
 }
@@ -44118,8 +44366,36 @@ function reviserIdentityInstructions(taskId, title) {
 ` : "";
   return `${lock}You revise a spec to address accepted issues. Return ONLY the full revised markdown, no commentary.`;
 }
+function gateCallRecorder(args) {
+  let round = 0;
+  let headSinceArbiter = false;
+  return function record2(role, persona, agentId, startedAt, result) {
+    if (role === "head" && !headSinceArbiter) {
+      round += 1;
+      headSinceArbiter = true;
+    }
+    if (role === "arbiter") headSinceArbiter = false;
+    if (args.stateDir === void 0) return;
+    const usage = "usage" in result ? result.usage : null;
+    recordGateCall(args.stateDir, args.projectSlug, {
+      day: telemetryDay(),
+      gate: args.gate,
+      round,
+      role,
+      persona,
+      agentId,
+      provider: args.provider,
+      inputTokens: usage?.inputTokens ?? null,
+      cachedInputTokens: usage?.cachedInputTokens ?? null,
+      cacheWriteInputTokens: usage?.cacheWriteInputTokens ?? null,
+      outputTokens: usage?.outputTokens ?? null,
+      durationMs: Date.now() - startedAt
+    });
+  };
+}
 function buildSpecGateDeps(args) {
-  const { client, projectSlug, specPageId, cwd, codexExecutable, extraHeadCount = 0, seat } = args;
+  const { client, projectSlug, specPageId, codexExecutable, extraHeadCount = 0, seat, stateDir } = args;
+  const recordCost = gateCallRecorder({ stateDir, projectSlug, gate: "spec", provider: seat?.id ?? null });
   const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 5);
   const maxHeadCalls = 2 * rounds * (MAX_DOMAIN_HEADS + extraHeadCount + 2);
   const timeoutMs = Number(process.env["MRRLIN_CONSENSUS_HEAD_TIMEOUT_MS"] ?? 15e4);
@@ -44194,7 +44470,8 @@ function buildSpecGateDeps(args) {
       const persona = loadPersona(personaName);
       const { taskId, title, seed, impact, adjudicated } = await loadIntent();
       const intentBlock = specHeadIntentBlock(taskId, title, seed, impact, adjudicated);
-      return runAgentExec(
+      const startedAt = Date.now();
+      const result = await runAgentExec(
         {
           prompt: `Review this spec against the operator's intent.
 
@@ -44203,19 +44480,26 @@ ${dismissed}
 ${intentBlock}--- SPEC ---
 ${artifact}`,
           developerInstructions: persona,
-          cwd,
+          // Every provider call in this factory runs from the empty per-process directory rather
+          // than the caller's repository — see sterile-cwd.ts for the measurement and the accepted
+          // risk. Nothing in a spec review reads the repository: the artifact and the operator
+          // intent are both in the prompt above.
+          cwd: sterileCwd(),
           timeoutMs,
           sandbox: "read-only",
           codexExecutable
         }
       );
+      recordCost("head", personaName, null, startedAt, result);
+      return result;
     },
     async runArbiter(prompt) {
-      return runAgentExec(
+      const startedAt = Date.now();
+      const result = await runAgentExec(
         {
           prompt,
           developerInstructions: loadPersona("arbiter"),
-          cwd,
+          cwd: sterileCwd(),
           timeoutMs,
           sandbox: "read-only",
           codexExecutable,
@@ -44224,11 +44508,14 @@ ${artifact}`,
           model: seat?.models.strong
         }
       );
+      recordCost("arbiter", "arbiter", seat?.models.strong ?? null, startedAt, result);
+      return result;
     },
     async runReviser(artifact, accepted) {
       const acceptedList = accepted.map((a) => `- (${a.category}) ${a.text}`).join("\n");
       const { taskId, title } = await loadIntent();
-      return runAgentExec(
+      const startedAt = Date.now();
+      const result = await runAgentExec(
         {
           prompt: `Accepted issues:
 ${acceptedList}
@@ -44236,12 +44523,16 @@ ${acceptedList}
 --- SPEC ---
 ${artifact}`,
           developerInstructions: reviserIdentityInstructions(taskId, title),
-          cwd,
+          // Sterile like the rest of this factory: the spec reviser rewrites the markdown it is
+          // handed and returns it, so unlike the CODE gate's reviser it never touches a worktree.
+          cwd: sterileCwd(),
           timeoutMs,
           sandbox: "read-only",
           codexExecutable
         }
       );
+      recordCost("reviser", null, null, startedAt, result);
+      return result;
     },
     async casUpdateSpec(markdownBody, expectedHash) {
       try {
@@ -44288,9 +44579,17 @@ ${artifact}`,
       const rounds2 = r["rounds"];
       const history = r["history"];
       const highlights = await curateFindings(Array.isArray(history) ? history : [], {
-        runCodexExec: runAgentExec,
+        // Wrapped, not passed raw: this is the one gate provider call that does NOT go through a
+        // `deps.run*` function, so without this the post-gate findings pass would be the single
+        // call the cost record silently omits.
+        runCodexExec: async (input) => {
+          const startedAt = Date.now();
+          const result = await runAgentExec(input);
+          recordCost("findings", "findings-writer", null, startedAt, result);
+          return result;
+        },
         loadPersona,
-        cwd,
+        cwd: sterileCwd(),
         timeoutMs,
         codexExecutable
       });
@@ -44313,7 +44612,8 @@ ${artifact}`,
   };
 }
 function buildCodeGateDeps(args) {
-  const { client, projectSlug, baseRef, cwd, codexExecutable, extraHeads, seat } = args;
+  const { client, projectSlug, baseRef, cwd, codexExecutable, extraHeads, seat, stateDir } = args;
+  const recordCost = gateCallRecorder({ stateDir, projectSlug, gate: "code", provider: seat?.id ?? null });
   const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 5);
   const heads = ["code-reviewer", ...extraHeads ?? []];
   const maxHeadCalls = 2 * rounds * (heads.length + 2);
@@ -44336,7 +44636,8 @@ function buildCodeGateDeps(args) {
     },
     async runHead(personaName, artifact, dismissed) {
       const persona = loadPersona(personaName);
-      return runAgentExec({
+      const startedAt = Date.now();
+      const result = await runAgentExec({
         prompt: `Review this code diff.
 
 ${dismissed}
@@ -44344,17 +44645,23 @@ ${dismissed}
 --- DIFF ---
 ${artifact}`,
         developerInstructions: persona,
-        cwd,
+        // Read-only review of a diff that is entirely in the prompt — sterile, per sterile-cwd.ts.
+        // This factory is the ONE that stays mixed: runReviser below keeps the real `cwd` because
+        // it edits the branch, and the git helpers keep it because they are not provider calls.
+        cwd: sterileCwd(),
         timeoutMs: headTimeoutMs,
         sandbox: "read-only",
         codexExecutable
       });
+      recordCost("head", personaName, null, startedAt, result);
+      return result;
     },
     async runArbiter(prompt) {
-      return runAgentExec({
+      const startedAt = Date.now();
+      const result = await runAgentExec({
         prompt,
         developerInstructions: loadPersona("arbiter"),
-        cwd,
+        cwd: sterileCwd(),
         timeoutMs: headTimeoutMs,
         sandbox: "read-only",
         codexExecutable,
@@ -44362,21 +44669,30 @@ ${artifact}`,
         // strongest model.
         model: seat?.models.strong
       });
+      recordCost("arbiter", "arbiter", seat?.models.strong ?? null, startedAt, result);
+      return result;
     },
     async runReviser(artifact, accepted) {
       const acceptedList = accepted.map((a) => `- (${a.category}) ${a.text}`).join("\n");
-      return runAgentExec({
+      const startedAt = Date.now();
+      const result = await runAgentExec({
         prompt: `Accepted issues to fix:
 ${acceptedList}
 
 --- DIFF ---
 ${artifact}`,
         developerInstructions: "You are fixing code review issues. Edit ONLY files already changed in this branch's diff; make the minimal change to resolve each accepted issue. Do not refactor unrelated code. Do not edit files outside the diff.",
+        // The real repository root, NOT sterileCwd(): this is the one gate call that runs
+        // `workspace-write` and edits the branch, so a sterile cwd would point the sandbox at an
+        // empty directory and the revision would silently apply to nothing — the gate would keep
+        // reporting rounds while fixing no code at all.
         cwd,
         timeoutMs: reviserTimeoutMs,
         sandbox: "workspace-write",
         codexExecutable
       });
+      recordCost("reviser", null, null, startedAt, result);
+      return result;
     },
     checkpoint() {
       return checkpoint(gitArgs);
@@ -44397,7 +44713,8 @@ function renderCriteriaBlock(criteria) {
   return criteria.map((c, i) => `${i + 1}. [ ] ${c}`).join("\n");
 }
 async function buildDeliverableGateDeps(args) {
-  const { client, projectSlug, deliverablePageId, attemptOutcome, cwd, codexExecutable, runId, seat } = args;
+  const { client, projectSlug, deliverablePageId, attemptOutcome, codexExecutable, runId, seat, stateDir } = args;
+  const recordCost = gateCallRecorder({ stateDir, projectSlug, gate: "deliverable", provider: seat?.id ?? null });
   const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 5);
   const timeoutMs = Number(process.env["MRRLIN_CONSENSUS_HEAD_TIMEOUT_MS"] ?? 15e4);
   const page = await client.getWikiPage(projectSlug, deliverablePageId);
@@ -44443,7 +44760,8 @@ async function buildDeliverableGateDeps(args) {
     },
     async runHead(personaName, artifact, dismissed) {
       const persona = loadPersona(personaName);
-      return runAgentExec({
+      const startedAt = Date.now();
+      const result = await runAgentExec({
         prompt: `Score this deliverable ITEM BY ITEM against the acceptance criteria below. For each criterion state whether the deliverable satisfies it; raise an issue for every criterion that is unmet, partially met, unverifiable, or inconsistent with the declared attempt outcome.
 
 ${dismissed}
@@ -44458,17 +44776,23 @@ ${artifact}`,
         developerInstructions: `${DELIVERABLE_ANTIINJECTION_INSTRUCTION}
 
 ${persona}`,
-        cwd,
+        // Sterile, like every other provider call in this factory — see sterile-cwd.ts. It also
+        // narrows the anti-injection surface: a deliverable that tries to talk the head into
+        // reading files now has no repository under it to read.
+        cwd: sterileCwd(),
         timeoutMs,
         sandbox: "read-only",
         codexExecutable
       });
+      recordCost("head", personaName, null, startedAt, result);
+      return result;
     },
     async runArbiter(prompt) {
-      return runAgentExec({
+      const startedAt = Date.now();
+      const result = await runAgentExec({
         prompt,
         developerInstructions: loadPersona("arbiter"),
-        cwd,
+        cwd: sterileCwd(),
         timeoutMs,
         sandbox: "read-only",
         codexExecutable,
@@ -44476,10 +44800,13 @@ ${persona}`,
         // strongest model.
         model: seat?.models.strong
       });
+      recordCost("arbiter", "arbiter", seat?.models.strong ?? null, startedAt, result);
+      return result;
     },
     async runReviser(artifact, accepted) {
       const acceptedList = accepted.map((a) => `- (${a.category}) ${a.text}`).join("\n");
-      return runAgentExec({
+      const startedAt = Date.now();
+      const result = await runAgentExec({
         prompt: `Accepted issues to fix (each maps to an unmet acceptance criterion):
 ${acceptedList}
 
@@ -44491,11 +44818,13 @@ ${artifact}`,
         developerInstructions: `${DELIVERABLE_ANTIINJECTION_INSTRUCTION}
 
 You revise a deliverable to address the accepted issues so it satisfies the acceptance criteria and stays consistent with the declared outcome${attemptOutcome ? ` (${attemptOutcome})` : ""}. Return ONLY the full revised markdown, no commentary. Do not invent facts; keep the deliverable's format and do not change the declared outcome.`,
-        cwd,
+        cwd: sterileCwd(),
         timeoutMs,
         sandbox: "read-only",
         codexExecutable
       });
+      recordCost("reviser", null, null, startedAt, result);
+      return result;
     },
     async casUpdateDeliverable(markdownBody, expectedHash) {
       try {
@@ -44526,7 +44855,7 @@ You revise a deliverable to address the accepted issues so it satisfies the acce
       const highlights = await curateFindings(Array.isArray(history) ? history : [], {
         runCodexExec: runAgentExec,
         loadPersona,
-        cwd,
+        cwd: sterileCwd(),
         timeoutMs,
         codexExecutable
       });
@@ -44649,10 +44978,35 @@ async function gate(artifact, prose, ctx) {
   return { ok: true, gated: false, artifact: maskedClone };
 }
 
+// src/telemetry/installation-id.ts
+var import_node_crypto5 = require("node:crypto");
+var import_node_fs8 = require("node:fs");
+var import_node_path14 = require("node:path");
+var FILE_NAME = "installation-id";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var cache = /* @__PURE__ */ new Map();
+function resolveInstallationId(stateDir) {
+  const cached2 = cache.get(stateDir);
+  if (cached2 !== void 0) return cached2;
+  const path22 = (0, import_node_path14.join)(stateDir, FILE_NAME);
+  let id;
+  try {
+    id = (0, import_node_fs8.readFileSync)(path22, "utf8").trim();
+    if (!UUID.test(id)) throw new Error("unusable");
+  } catch {
+    id = (0, import_node_crypto5.randomUUID)();
+    (0, import_node_fs8.mkdirSync)((0, import_node_path14.dirname)(path22), { recursive: true });
+    (0, import_node_fs8.writeFileSync)(path22, `${id}
+`, "utf8");
+  }
+  cache.set(stateDir, id);
+  return id;
+}
+
 // src/telemetry/daily-uploader.ts
 var ROWS_FILE_RE = /^rows-(.+)-(\d{4}-\d{2}-\d{2})\.jsonl$/;
 async function uploadPendingDays(stateDir, client, bridgeHealth, gateCtx) {
-  const telemetryDir = (0, import_node_path12.join)(stateDir, "telemetry");
+  const telemetryDir = (0, import_node_path15.join)(stateDir, "telemetry");
   let files;
   try {
     files = await (0, import_promises6.readdir)(telemetryDir);
@@ -44665,11 +45019,11 @@ async function uploadPendingDays(stateDir, client, bridgeHealth, gateCtx) {
     const match = ROWS_FILE_RE.exec(file2);
     if (!match) continue;
     const [, projectSlug, day] = match;
-    const markerPath = (0, import_node_path12.join)(telemetryDir, `.processed-${projectSlug}-${day}`);
+    const markerPath = (0, import_node_path15.join)(telemetryDir, `.processed-${projectSlug}-${day}`);
     try {
       await (0, import_promises6.access)(markerPath);
     } catch {
-      pending.push({ projectSlug, day, rowsPath: (0, import_node_path12.join)(telemetryDir, file2), markerPath });
+      pending.push({ projectSlug, day, rowsPath: (0, import_node_path15.join)(telemetryDir, file2), markerPath });
     }
   }
   if (pending.length === 0) return;
@@ -44677,7 +45031,7 @@ async function uploadPendingDays(stateDir, client, bridgeHealth, gateCtx) {
   const fullUnprocessed = pending.map((p) => ({ projectSlug: p.projectSlug, day: p.day }));
   pending.sort((a, b) => a.day.localeCompare(b.day));
   for (const cur of pending) {
-    const failurePath = (0, import_node_path12.join)(telemetryDir, `.failed-${cur.projectSlug}-${cur.day}.json`);
+    const failurePath = (0, import_node_path15.join)(telemetryDir, `.failed-${cur.projectSlug}-${cur.day}.json`);
     let failureState = null;
     try {
       const data = await (0, import_promises6.readFile)(failurePath, "utf8");
@@ -44706,14 +45060,31 @@ async function uploadPendingDays(stateDir, client, bridgeHealth, gateCtx) {
         } catch {
         }
       }
+      const gateCalls = [];
+      try {
+        const rawGate = await (0, import_promises6.readFile)((0, import_node_path15.join)(telemetryDir, gateFileName(cur.projectSlug, cur.day)), "utf8");
+        for (const line of rawGate.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            gateCalls.push(JSON.parse(line));
+          } catch {
+          }
+        }
+      } catch {
+      }
       const batch = {
         day: cur.day,
         bridgeVersion: PKG_VERSION,
+        installationId: resolveInstallationId(stateDir),
         knownCrashCount,
         unprocessedPartitions: fullUnprocessed.filter(
           (p) => !(p.projectSlug === cur.projectSlug && p.day === cur.day)
         ),
-        rows
+        rows,
+        // Omitted entirely when empty: an absent array and an empty one mean the same thing to
+        // every reader, and not sending the key keeps a gate-free day's batch byte-identical to
+        // what every uploader before this change produced.
+        ...gateCalls.length > 0 ? { gateCalls } : {}
       };
       const gateResult = await gate(batch, [], gateCtx);
       const gateMarker = gateResult.gated ? "gated" : "projection-only";
@@ -45107,8 +45478,8 @@ function setSelectedProvider(value) {
 
 // src/execution-consumer.ts
 var import_node_child_process12 = require("node:child_process");
-var import_node_crypto6 = __toESM(require("node:crypto"), 1);
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_crypto7 = __toESM(require("node:crypto"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
 
 // src/consensus/deliverable-gate-outcome.ts
@@ -45178,7 +45549,7 @@ function mapDeliverableGateResult(result) {
 }
 
 // src/async-tools/draft-spec.ts
-var import_node_crypto5 = require("node:crypto");
+var import_node_crypto6 = require("node:crypto");
 var DRAFT_SPEC_TOOL_NAME = "draft_task_spec";
 var SPECS_FOLDER = "Specs";
 var DRAFT_SPEC_TLDR_MAX_CHARS = 300;
@@ -45673,7 +46044,7 @@ function onComplete(outcome, input) {
     };
   }
   const summary = outcome.error;
-  const hash3 = (0, import_node_crypto5.createHash)("sha256").update(summary).digest("hex").slice(0, 10);
+  const hash3 = (0, import_node_crypto6.createHash)("sha256").update(summary).digest("hex").slice(0, 10);
   return {
     kind: "info",
     id: `II-sched-draft-failed-${input.taskId}-${hash3}`,
@@ -46404,18 +46775,18 @@ async function awaitTurnWithDeadline(opts) {
 
 // src/worktree.ts
 var import_node_child_process11 = require("node:child_process");
-var import_node_fs7 = require("node:fs");
-var import_node_os6 = require("node:os");
-var import_node_path14 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_os7 = require("node:os");
+var import_node_path17 = require("node:path");
 
 // src/checkout-lock.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path16 = require("node:path");
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 async function withCheckoutLock(locksDir, slug, fn) {
-  (0, import_node_fs6.mkdirSync)(locksDir, { recursive: true });
-  const target = (0, import_node_path13.join)(locksDir, `${slug}.lock`);
-  if (!(0, import_node_fs6.existsSync)(target)) (0, import_node_fs6.writeFileSync)(target, "");
+  (0, import_node_fs9.mkdirSync)(locksDir, { recursive: true });
+  const target = (0, import_node_path16.join)(locksDir, `${slug}.lock`);
+  if (!(0, import_node_fs9.existsSync)(target)) (0, import_node_fs9.writeFileSync)(target, "");
   const release = await import_proper_lockfile.default.lock(target, {
     retries: { retries: 600, factor: 1, minTimeout: 100, maxTimeout: 100 },
     stale: 5 * 6e4
@@ -46440,12 +46811,12 @@ function git(checkout, args) {
   });
 }
 async function createRunWorktree(opts) {
-  const worktreePath = (0, import_node_path14.join)(opts.worktreeRoot, opts.slug, opts.runId);
+  const worktreePath = (0, import_node_path17.join)(opts.worktreeRoot, opts.slug, opts.runId);
   await withCheckoutLock(opts.locksDir, opts.slug, async () => {
-    (0, import_node_fs7.mkdirSync)(opts.worktreeRoot, { recursive: true });
+    (0, import_node_fs10.mkdirSync)(opts.worktreeRoot, { recursive: true });
     try {
       git(opts.checkout, ["fetch", "origin", opts.defaultBranch]);
-      if (!(0, import_node_fs7.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs10.existsSync)(worktreePath)) {
         git(opts.checkout, [
           "worktree",
           "add",
@@ -46517,15 +46888,15 @@ async function doPushRunBranch(opts, execGit) {
   if (localConfig.trim()) {
     throw new Error(`push aborted: agent-controlled git config present in worktree: ${localConfig.trim().split("\n")[0]}`);
   }
-  const dir = (0, import_node_fs7.mkdtempSync)((0, import_node_path14.join)((0, import_node_os6.tmpdir)(), "mrrlin-push-"));
-  const askpass = (0, import_node_path14.join)(dir, "askpass");
+  const dir = (0, import_node_fs10.mkdtempSync)((0, import_node_path17.join)((0, import_node_os7.tmpdir)(), "mrrlin-push-"));
+  const askpass = (0, import_node_path17.join)(dir, "askpass");
   try {
-    (0, import_node_fs7.writeFileSync)(
+    (0, import_node_fs10.writeFileSync)(
       askpass,
       '#!/bin/sh\ncase "$1" in *[Uu]sername*) printf %s "x-access-token" ;; *) printf %s "$MRRLIN_PUSH_TOKEN" ;; esac\n',
       { mode: 320 }
     );
-    (0, import_node_fs7.chmodSync)(askpass, 320);
+    (0, import_node_fs10.chmodSync)(askpass, 320);
     execGit(
       [
         "-C",
@@ -46544,18 +46915,18 @@ async function doPushRunBranch(opts, execGit) {
     );
     return { pushedSha: localSha };
   } finally {
-    (0, import_node_fs7.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs10.rmSync)(dir, { recursive: true, force: true });
   }
 }
 async function sweepOrphanWorktrees(opts) {
   const reaped = [];
   const ownedPrefix = (() => {
     try {
-      return (0, import_node_fs7.realpathSync)(opts.worktreeRoot);
+      return (0, import_node_fs10.realpathSync)(opts.worktreeRoot);
     } catch {
       return opts.worktreeRoot;
     }
-  })() + import_node_path14.sep + opts.slug + import_node_path14.sep;
+  })() + import_node_path17.sep + opts.slug + import_node_path17.sep;
   await withCheckoutLock(opts.locksDir, opts.slug, async () => {
     const listing = git(opts.checkout, ["worktree", "list", "--porcelain"]);
     for (const block of listing.split("\n\n")) {
@@ -47075,7 +47446,7 @@ function isBridgeGeneratedArtifact(artifact) {
   return typeof payload === "object" && payload !== null && "event" in payload;
 }
 function newArtifactId() {
-  return `EA-${import_node_crypto6.default.randomUUID()}`;
+  return `EA-${import_node_crypto7.default.randomUUID()}`;
 }
 var BLAST_RADIUS_FLOOR_PATTERNS = [/^supabase\/migrations\//, /^packages\/db\/src\/schema\.ts$/];
 function isBlastRadiusFloorPath(path22) {
@@ -47317,7 +47688,7 @@ async function driveRun(deps, projectSlug, runId) {
   if (!claimed) return;
   if (!claimed.leaseId) {
     await deps.client.createInboxItem(projectSlug, {
-      id: `II-${import_node_crypto6.default.randomUUID()}`,
+      id: `II-${import_node_crypto7.default.randomUUID()}`,
       kind: "handoff",
       taskId: claimed.taskId,
       body: `Execution run ${runId} was claimed but returned no leaseId. This indicates DB/API corruption and requires operator attention.`
@@ -47334,6 +47705,35 @@ async function driveRun(deps, projectSlug, runId) {
     return legacy != null ? Math.min(legacy, remaining) : remaining;
   };
   const task = await deps.client.getTask(projectSlug, claimed.taskId);
+  if (task.declaredOutcome != null) {
+    for (const kind of task.declaredOutcome.requires) {
+      if (resolveKindCapability(kind) === null) {
+        await failRun(
+          deps,
+          projectSlug,
+          task,
+          runId,
+          leaseId,
+          `capability_not_routed: run ${runId} targets ${task.id}, which requires artifact kind "${kind}" -- that kind has no capability at all`,
+          "capability_not_routed"
+        );
+        return;
+      }
+      const routeResolution = await deps.client.resolveArtifactKindRoute(projectSlug, kind, projectSlug);
+      if (!routeResolution.ok) {
+        await failRun(
+          deps,
+          projectSlug,
+          task,
+          runId,
+          leaseId,
+          `capability_not_routed: run ${runId} targets ${task.id}, which requires artifact kind "${kind}" -- no route (${routeResolution.reason})`,
+          "capability_not_routed"
+        );
+        return;
+      }
+    }
+  }
   const blockerTasks = task.blockedBy.length ? await Promise.all(task.blockedBy.map((blockerTaskId) => deps.client.getTask(projectSlug, blockerTaskId))) : [];
   const missingBlockers = task.blockedBy.filter((_, index) => !blockerTasks[index]);
   if (missingBlockers.length > 0) {
@@ -48494,7 +48894,7 @@ async function reconcileTaskAwaitingMerge(deps, projectSlug, task, runId, reason
   }
   try {
     await deps.client.createInboxItem(projectSlug, {
-      id: `II-${import_node_crypto6.default.randomUUID()}`,
+      id: `II-${import_node_crypto7.default.randomUUID()}`,
       kind: "handoff",
       taskId: task.id,
       body: `Task ${task.id} (${task.title}) still needs operator follow-up: ${reason}. Mrrlin could not move the task back to Handoff needed automatically.`
@@ -48529,7 +48929,7 @@ async function notifyOperatorHandoff(deps, projectSlug, task, runId, reason) {
   }
   try {
     await deps.client.createInboxItem(projectSlug, {
-      id: `II-${import_node_crypto6.default.randomUUID()}`,
+      id: `II-${import_node_crypto7.default.randomUUID()}`,
       kind: "handoff",
       taskId: task.id,
       body: `Execution run ${runId} for task ${task.id} (${task.title}) needs operator attention: ${reason}`
@@ -48669,8 +49069,8 @@ async function runBackstopSweep(deps, drive = (slug, id) => driveRun(deps, slug,
 function isRunRecoverableByThisBridge(run3, worktreeRoot) {
   if (!worktreeRoot) return true;
   if (!run3.worktreeId) return false;
-  const relative = import_node_path15.default.relative(import_node_path15.default.resolve(worktreeRoot), import_node_path15.default.resolve(run3.worktreeId));
-  return relative === "" || relative.length > 0 && !relative.startsWith("..") && !import_node_path15.default.isAbsolute(relative);
+  const relative = import_node_path18.default.relative(import_node_path18.default.resolve(worktreeRoot), import_node_path18.default.resolve(run3.worktreeId));
+  return relative === "" || relative.length > 0 && !relative.startsWith("..") && !import_node_path18.default.isAbsolute(relative);
 }
 async function deployGateHandoff(deps, projectSlug, task, runId, reason, leaseId) {
   await deps.client.updateExecutionRun(projectSlug, runId, { status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), leaseId: leaseId ?? void 0 }).catch(() => {
@@ -48688,7 +49088,7 @@ async function deployGateHandoff(deps, projectSlug, task, runId, reason, leaseId
   }).catch(() => {
   });
   await deps.client.createInboxItem(projectSlug, {
-    id: `II-${import_node_crypto6.default.randomUUID()}`,
+    id: `II-${import_node_crypto7.default.randomUUID()}`,
     kind: "handoff",
     taskId: task.id,
     body: `Deploy gate for run ${runId} (task ${task.id} \u2014 ${task.title}) needs operator attention: ${reason}`
@@ -48707,7 +49107,7 @@ function maxLeaseReclaims() {
 }
 
 // src/async-job-consumer.ts
-var import_node_crypto8 = __toESM(require("node:crypto"), 1);
+var import_node_crypto9 = __toESM(require("node:crypto"), 1);
 
 // src/async-tools/registry.ts
 var registry2 = /* @__PURE__ */ new Map();
@@ -48719,9 +49119,9 @@ function getAsyncToolDescriptor(toolName) {
 }
 
 // src/bridge-log.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_promises7 = require("node:fs/promises");
-var import_node_path16 = require("node:path");
+var import_node_path19 = require("node:path");
 
 // src/redact.ts
 var REDACTED = "[REDACTED]";
@@ -48746,7 +49146,7 @@ function redact(input) {
 }
 
 // src/telemetry/projector.ts
-var import_node_crypto7 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 function isRecord2(x) {
   return typeof x === "object" && x !== null;
 }
@@ -48787,7 +49187,7 @@ function buildProjection(payload, type, ms, telemetry) {
       if (typeof exitCode === "number") proj.exitCode = exitCode;
       const status = tool.status;
       if (typeof status === "string" && status.trim() !== "") {
-        proj.statusHash = (0, import_node_crypto7.createHash)("sha256").update(status.trim().toLowerCase()).digest("hex").slice(0, 8);
+        proj.statusHash = (0, import_node_crypto8.createHash)("sha256").update(status.trim().toLowerCase()).digest("hex").slice(0, 8);
       }
       return proj;
     }
@@ -48997,14 +49397,14 @@ function resolvePromptsEnabled(env = process.env) {
 }
 function createBridgeLogger(stateDir, env = process.env) {
   if (!resolveBridgeLogEnabled(env)) return NOOP_LOGGER;
-  const logsDir = (0, import_node_path16.join)(stateDir, "logs");
+  const logsDir = (0, import_node_path19.join)(stateDir, "logs");
   try {
-    (0, import_node_fs8.mkdirSync)(logsDir, { recursive: true });
+    (0, import_node_fs11.mkdirSync)(logsDir, { recursive: true });
   } catch {
     return NOOP_LOGGER;
   }
   const includePrompts = resolvePromptsEnabled(env);
-  const fileFor = () => (0, import_node_path16.join)(logsDir, `bridge-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`);
+  const fileFor = () => (0, import_node_path19.join)(logsDir, `bridge-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`);
   const MAX_TRACKED_SESSIONS = 64;
   const contextSlugBySession = /* @__PURE__ */ new Map();
   const rememberContextSlug = (sessionId, payload) => {
@@ -49045,10 +49445,10 @@ function createBridgeLogger(stateDir, env = process.env) {
     return { isGap, isNewTurn };
   };
   const gainDay = (sessionId) => {
-    const sessionsPath = (0, import_node_path16.join)(logsDir, ".sessions.json");
+    const sessionsPath = (0, import_node_path19.join)(logsDir, ".sessions.json");
     let sessionsObj = {};
     try {
-      const parsed = JSON.parse((0, import_node_fs8.readFileSync)(sessionsPath, "utf8"));
+      const parsed = JSON.parse((0, import_node_fs11.readFileSync)(sessionsPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) sessionsObj = parsed;
     } catch {
       sessionsObj = {};
@@ -49058,8 +49458,8 @@ function createBridgeLogger(stateDir, env = process.env) {
     if (idsToday.includes(sessionId)) return;
     sessionsObj[day] = [...idsToday, sessionId];
     const tmpPath = `${sessionsPath}.tmp`;
-    (0, import_node_fs8.writeFileSync)(tmpPath, JSON.stringify(sessionsObj));
-    (0, import_node_fs8.renameSync)(tmpPath, sessionsPath);
+    (0, import_node_fs11.writeFileSync)(tmpPath, JSON.stringify(sessionsObj));
+    (0, import_node_fs11.renameSync)(tmpPath, sessionsPath);
   };
   const write = (dir, rec) => {
     try {
@@ -49150,7 +49550,7 @@ function createBridgeLogger(stateDir, env = process.env) {
         ...recordingObligationUnresolved ? { recordingObligationUnresolved } : {},
         ...recordingObligationMultiResolve ? { recordingObligationMultiResolve } : {}
       }) + "\n";
-      (0, import_node_fs8.appendFileSync)(fileFor(), line);
+      (0, import_node_fs11.appendFileSync)(fileFor(), line);
       if (rec.sessionId !== null) gainDay(rec.sessionId);
     } catch {
     }
@@ -49163,7 +49563,7 @@ function createBridgeLogger(stateDir, env = process.env) {
   };
 }
 async function findSessionDays(stateDir, sessionId) {
-  const sessionsPath = (0, import_node_path16.join)(stateDir, "logs", ".sessions.json");
+  const sessionsPath = (0, import_node_path19.join)(stateDir, "logs", ".sessions.json");
   let sessionsObj;
   try {
     const parsed = JSON.parse(await (0, import_promises7.readFile)(sessionsPath, "utf8"));
@@ -49295,7 +49695,7 @@ async function driveAsyncJob(deps, projectSlug, jobId) {
   const delivery = descriptor2.onComplete(outcome, input);
   if (!delivery.suppressInbox) {
     await deps.client.createInboxItem(projectSlug, {
-      id: delivery.id ?? `II-${import_node_crypto8.default.randomUUID()}`,
+      id: delivery.id ?? `II-${import_node_crypto9.default.randomUUID()}`,
       kind: delivery.kind,
       body: delivery.body,
       ...delivery.taskId ? { taskId: delivery.taskId } : {},
@@ -49313,13 +49713,13 @@ async function deriveRequestedHash(client, toolName, input) {
   if (input.requestedHash) return input.requestedHash;
   if (toolName === "run_spec_consensus" && input.pageId) {
     const page = await client.getWikiPage(input.projectSlug, input.pageId);
-    return page.contentHash ?? import_node_crypto8.default.createHash("sha256").update(page.markdownBody).digest("hex");
+    return page.contentHash ?? import_node_crypto9.default.createHash("sha256").update(page.markdownBody).digest("hex");
   }
   if (toolName === "draft_task_spec" && input.taskId) {
     const task = await client.getTask(input.projectSlug, input.taskId);
-    return task.updatedAt ?? import_node_crypto8.default.createHash("sha256").update(JSON.stringify(task)).digest("hex");
+    return task.updatedAt ?? import_node_crypto9.default.createHash("sha256").update(JSON.stringify(task)).digest("hex");
   }
-  return import_node_crypto8.default.createHash("sha256").update(JSON.stringify(input)).digest("hex");
+  return import_node_crypto9.default.createHash("sha256").update(JSON.stringify(input)).digest("hex");
 }
 async function runAsyncBackstopSweep(deps, drive = (slug, jobId) => driveAsyncJob(deps, slug, jobId)) {
   const projects = await deps.client.listProjects();
@@ -49597,19 +49997,19 @@ function agentIdleMs(provider) {
 }
 
 // src/operator-token.ts
-var import_node_fs9 = require("node:fs");
-var import_node_os7 = __toESM(require("node:os"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_fs12 = require("node:fs");
+var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
 function operatorDir() {
-  const base = process.env.CODEX_HOME ? import_node_path17.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path17.default.join(import_node_os7.default.homedir(), ".mrrlin");
+  const base = process.env.CODEX_HOME ? import_node_path20.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path20.default.join(import_node_os8.default.homedir(), ".mrrlin");
   return base;
 }
 function operatorTokenPath() {
-  return import_node_path17.default.join(operatorDir(), "operator-token");
+  return import_node_path20.default.join(operatorDir(), "operator-token");
 }
 function readOperatorToken() {
   try {
-    const token = (0, import_node_fs9.readFileSync)(operatorTokenPath(), "utf8").trim();
+    const token = (0, import_node_fs12.readFileSync)(operatorTokenPath(), "utf8").trim();
     return token.length > 0 ? token : null;
   } catch {
     return null;
@@ -49617,24 +50017,24 @@ function readOperatorToken() {
 }
 function persistOperatorToken(token) {
   const dir = operatorDir();
-  (0, import_node_fs9.mkdirSync)(dir, { recursive: true, mode: 448 });
-  (0, import_node_fs9.writeFileSync)(operatorTokenPath(), `${token.trim()}
+  (0, import_node_fs12.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs12.writeFileSync)(operatorTokenPath(), `${token.trim()}
 `, { encoding: "utf8", mode: 384 });
 }
 function agentCredentialPath() {
-  return import_node_path17.default.join(operatorDir(), "agent-credential");
+  return import_node_path20.default.join(operatorDir(), "agent-credential");
 }
 function persistAgentSecret(secret) {
   const dir = operatorDir();
-  (0, import_node_fs9.mkdirSync)(dir, { recursive: true, mode: 448 });
-  (0, import_node_fs9.writeFileSync)(agentCredentialPath(), `${secret.trim()}
+  (0, import_node_fs12.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs12.writeFileSync)(agentCredentialPath(), `${secret.trim()}
 `, { encoding: "utf8", mode: 384 });
 }
 function readAgentSecret() {
   const fromEnv = process.env.MRRLIN_AGENT_SECRET?.trim();
   if (fromEnv) return fromEnv;
   try {
-    const raw = (0, import_node_fs9.readFileSync)(agentCredentialPath(), "utf8").trim();
+    const raw = (0, import_node_fs12.readFileSync)(agentCredentialPath(), "utf8").trim();
     return raw || void 0;
   } catch {
     return void 0;
@@ -49642,16 +50042,16 @@ function readAgentSecret() {
 }
 
 // src/thread-index.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_fs13 = require("node:fs");
+var import_node_path21 = __toESM(require("node:path"), 1);
 function threadIndexPath(stateDir) {
-  return import_node_path18.default.join(stateDir, "threads.json");
+  return import_node_path21.default.join(stateDir, "threads.json");
 }
 function loadThreadIndex(stateDir, ttlMs, now) {
   const result = /* @__PURE__ */ new Map();
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs10.readFileSync)(threadIndexPath(stateDir), "utf8"));
+    parsed = JSON.parse((0, import_node_fs13.readFileSync)(threadIndexPath(stateDir), "utf8"));
   } catch {
     return result;
   }
@@ -49674,8 +50074,8 @@ function loadThreadIndex(stateDir, ttlMs, now) {
   return result;
 }
 function saveThreadIndex(stateDir, entries) {
-  (0, import_node_fs10.mkdirSync)(stateDir, { recursive: true, mode: 448 });
-  (0, import_node_fs10.writeFileSync)(threadIndexPath(stateDir), `${JSON.stringify(Object.fromEntries(entries), null, 2)}
+  (0, import_node_fs13.mkdirSync)(stateDir, { recursive: true, mode: 448 });
+  (0, import_node_fs13.writeFileSync)(threadIndexPath(stateDir), `${JSON.stringify(Object.fromEntries(entries), null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
@@ -49810,10 +50210,10 @@ function createToolBusyClock(opts) {
 }
 
 // src/worker-token.ts
-var import_node_crypto9 = require("node:crypto");
-var import_node_fs11 = require("node:fs");
-var import_node_os8 = __toESM(require("node:os"), 1);
-var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_crypto10 = require("node:crypto");
+var import_node_fs14 = require("node:fs");
+var import_node_os9 = __toESM(require("node:os"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
 var DEFAULT_WORKER_PORT = 8792;
 function workerPort() {
   const raw = process.env.MRRLIN_WORKER_PORT;
@@ -49822,15 +50222,15 @@ function workerPort() {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_WORKER_PORT;
 }
 function workerDir() {
-  const base = process.env.CODEX_HOME ? import_node_path19.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path19.default.join(import_node_os8.default.homedir(), ".mrrlin");
-  return import_node_path19.default.join(base, "worker");
+  const base = process.env.CODEX_HOME ? import_node_path22.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path22.default.join(import_node_os9.default.homedir(), ".mrrlin");
+  return import_node_path22.default.join(base, "worker");
 }
 function workerTokenPath() {
-  return import_node_path19.default.join(workerDir(), "token");
+  return import_node_path22.default.join(workerDir(), "token");
 }
 function readWorkerToken() {
   try {
-    const token = (0, import_node_fs11.readFileSync)(workerTokenPath(), "utf8").trim();
+    const token = (0, import_node_fs14.readFileSync)(workerTokenPath(), "utf8").trim();
     return token.length > 0 ? token : null;
   } catch {
     return null;
@@ -49840,18 +50240,18 @@ function readOrCreateWorkerToken() {
   const existing = readWorkerToken();
   if (existing) return existing;
   const dir = workerDir();
-  (0, import_node_fs11.mkdirSync)(dir, { recursive: true, mode: 448 });
-  const token = (0, import_node_crypto9.randomBytes)(32).toString("hex");
-  (0, import_node_fs11.writeFileSync)(workerTokenPath(), `${token}
+  (0, import_node_fs14.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const token = (0, import_node_crypto10.randomBytes)(32).toString("hex");
+  (0, import_node_fs14.writeFileSync)(workerTokenPath(), `${token}
 `, { encoding: "utf8", mode: 384 });
   return token;
 }
 
 // src/remote-phone-relay.ts
 var import_node_events2 = require("node:events");
-var import_node_fs12 = require("node:fs");
-var import_node_os9 = require("node:os");
-var import_node_path20 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_os10 = require("node:os");
+var import_node_path23 = require("node:path");
 
 // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/cryptoNode.js
 var nc = __toESM(require("node:crypto"), 1);
@@ -53422,9 +53822,9 @@ var DirectorRelay = class {
 
 // src/remote-phone-relay.ts
 function loadOrCreateAgentDeviceKey() {
-  const path22 = (0, import_node_path20.join)((0, import_node_os9.homedir)(), ".mrrlin", "agent-device-key");
+  const path22 = (0, import_node_path23.join)((0, import_node_os10.homedir)(), ".mrrlin", "agent-device-key");
   try {
-    const raw = JSON.parse((0, import_node_fs12.readFileSync)(path22, "utf8"));
+    const raw = JSON.parse((0, import_node_fs15.readFileSync)(path22, "utf8"));
     if (typeof raw.priv === "string" && typeof raw.pub === "string") {
       return { privateKey: fromBase64Url(raw.priv), publicKey: fromBase64Url(raw.pub) };
     }
@@ -53432,8 +53832,8 @@ function loadOrCreateAgentDeviceKey() {
   }
   const kp = generateIdentityKeyPair();
   try {
-    (0, import_node_fs12.mkdirSync)((0, import_node_path20.join)((0, import_node_os9.homedir)(), ".mrrlin"), { recursive: true });
-    (0, import_node_fs12.writeFileSync)(
+    (0, import_node_fs15.mkdirSync)((0, import_node_path23.join)((0, import_node_os10.homedir)(), ".mrrlin"), { recursive: true });
+    (0, import_node_fs15.writeFileSync)(
       path22,
       JSON.stringify({ priv: toBase64Url(kp.privateKey), pub: toBase64Url(kp.publicKey) }),
       { mode: 384 }
@@ -53442,10 +53842,10 @@ function loadOrCreateAgentDeviceKey() {
   }
   return kp;
 }
-var AGENT_PAIRING_PATH = (0, import_node_path20.join)((0, import_node_os9.homedir)(), ".mrrlin", "agent-pairing.json");
+var AGENT_PAIRING_PATH = (0, import_node_path23.join)((0, import_node_os10.homedir)(), ".mrrlin", "agent-pairing.json");
 function loadAgentPairing() {
   try {
-    const raw = JSON.parse((0, import_node_fs12.readFileSync)(AGENT_PAIRING_PATH, "utf8"));
+    const raw = JSON.parse((0, import_node_fs15.readFileSync)(AGENT_PAIRING_PATH, "utf8"));
     if (typeof raw.channelId === "string" && typeof raw.agentControlSecret === "string" && typeof raw.relayAuth === "string" && typeof raw.peerIdentityKey === "string") {
       return {
         channelId: raw.channelId,
@@ -53460,8 +53860,8 @@ function loadAgentPairing() {
 }
 function saveAgentPairing(record2) {
   try {
-    (0, import_node_fs12.mkdirSync)((0, import_node_path20.join)((0, import_node_os9.homedir)(), ".mrrlin"), { recursive: true });
-    (0, import_node_fs12.writeFileSync)(AGENT_PAIRING_PATH, JSON.stringify(record2), { mode: 384 });
+    (0, import_node_fs15.mkdirSync)((0, import_node_path23.join)((0, import_node_os10.homedir)(), ".mrrlin"), { recursive: true });
+    (0, import_node_fs15.writeFileSync)(AGENT_PAIRING_PATH, JSON.stringify(record2), { mode: 384 });
   } catch {
   }
 }
@@ -53639,18 +54039,18 @@ async function renderPairingQrSvg(payload) {
 }
 
 // src/checkout-registry.ts
-var import_node_fs13 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs16 = require("node:fs");
+var import_node_path24 = require("node:path");
 var CheckoutRegistry = class {
   file;
   constructor(stateDir) {
-    this.file = (0, import_node_path21.join)(stateDir, "checkouts.json");
-    (0, import_node_fs13.mkdirSync)(stateDir, { recursive: true });
+    this.file = (0, import_node_path24.join)(stateDir, "checkouts.json");
+    (0, import_node_fs16.mkdirSync)(stateDir, { recursive: true });
   }
   read() {
-    if (!(0, import_node_fs13.existsSync)(this.file)) return {};
+    if (!(0, import_node_fs16.existsSync)(this.file)) return {};
     try {
-      return JSON.parse((0, import_node_fs13.readFileSync)(this.file, "utf8"));
+      return JSON.parse((0, import_node_fs16.readFileSync)(this.file, "utf8"));
     } catch {
       return {};
     }
@@ -53661,13 +54061,13 @@ var CheckoutRegistry = class {
   confirm(slug, path22, now) {
     const all = this.read();
     all[slug] = { path: path22, confirmedAt: now };
-    (0, import_node_fs13.writeFileSync)(this.file, JSON.stringify(all, null, 2));
+    (0, import_node_fs16.writeFileSync)(this.file, JSON.stringify(all, null, 2));
   }
 };
 
 // src/checkout-handlers.ts
 var import_node_child_process13 = require("node:child_process");
-var import_node_fs14 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 
 // src/git-remote-match.ts
 function normalizeRemote(url2) {
@@ -53702,7 +54102,7 @@ function validateCheckoutPath(checkoutPath, repo) {
   }
   let resolvedPath;
   try {
-    resolvedPath = (0, import_node_fs14.realpathSync)(trimmedPath);
+    resolvedPath = (0, import_node_fs17.realpathSync)(trimmedPath);
   } catch {
     return {
       ok: false,
@@ -54008,9 +54408,9 @@ function extractVerificationSection(markdown) {
 }
 
 // src/director-reseed.ts
-var import_node_fs15 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 var import_node_readline = require("node:readline");
-var import_node_path22 = require("node:path");
+var import_node_path25 = require("node:path");
 function estimateTokens(s) {
   return Buffer.byteLength(s, "utf8");
 }
@@ -54142,9 +54542,9 @@ async function readSessionRows(logsDir, files, sessionIds) {
   const lines2 = [];
   let missingFiles = 0;
   for (const f of files) {
-    const filePath = (0, import_node_path22.join)(logsDir, f);
+    const filePath = (0, import_node_path25.join)(logsDir, f);
     try {
-      const stream = (0, import_node_fs15.createReadStream)(filePath, { encoding: "utf8" });
+      const stream = (0, import_node_fs18.createReadStream)(filePath, { encoding: "utf8" });
       const rl = (0, import_node_readline.createInterface)({ input: stream, crlfDelay: Infinity });
       try {
         for await (const line of rl) {
@@ -54168,18 +54568,18 @@ async function readSessionRows(logsDir, files, sessionIds) {
 }
 
 // src/external-agents-scrub.ts
-var import_node_fs16 = __toESM(require("node:fs"), 1);
-var import_node_os10 = __toESM(require("node:os"), 1);
-var import_node_path23 = __toESM(require("node:path"), 1);
+var import_node_fs19 = __toESM(require("node:fs"), 1);
+var import_node_os11 = __toESM(require("node:os"), 1);
+var import_node_path26 = __toESM(require("node:path"), 1);
 var REDACTION = "[REDACTED]";
 var SHORT_VALUE_THRESHOLD = 8;
-var KEYS_ENV_PATH = () => import_node_path23.default.join(import_node_os10.default.homedir(), ".local", "state", "external-agents", "keys.env");
+var KEYS_ENV_PATH = () => import_node_path26.default.join(import_node_os11.default.homedir(), ".local", "state", "external-agents", "keys.env");
 var keysEnvCache = null;
 function readKeysEnv() {
   const filePath = KEYS_ENV_PATH();
   let mtimeMs = 0;
   try {
-    mtimeMs = import_node_fs16.default.statSync(filePath).mtimeMs;
+    mtimeMs = import_node_fs19.default.statSync(filePath).mtimeMs;
   } catch {
     mtimeMs = 0;
   }
@@ -54188,7 +54588,7 @@ function readKeysEnv() {
   }
   const map2 = /* @__PURE__ */ new Map();
   try {
-    const content = import_node_fs16.default.readFileSync(filePath, "utf8");
+    const content = import_node_fs19.default.readFileSync(filePath, "utf8");
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
       if (line === "" || line.startsWith("#")) continue;
@@ -54606,7 +55006,7 @@ function addBridgeModel(target, model) {
 }
 function readTextIfExists(filePath) {
   try {
-    return import_node_fs17.default.readFileSync(filePath, "utf8");
+    return import_node_fs20.default.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -54617,9 +55017,9 @@ function readKnownGptSlugsFromTomlFile(filePath) {
   return Array.from(raw.matchAll(/^\s*model\s*=\s*"([^"]+)"/gm)).map((match) => match[1]?.trim() ?? "").filter(isSelectableModelSlug);
 }
 function readCodexFallbackModels() {
-  const codexHome = process.env.CODEX_HOME?.trim() || import_node_path24.default.join(import_node_os11.default.homedir(), ".codex");
+  const codexHome = process.env.CODEX_HOME?.trim() || import_node_path27.default.join(import_node_os12.default.homedir(), ".codex");
   const models = /* @__PURE__ */ new Map();
-  const cachePath = import_node_path24.default.join(codexHome, "models_cache.json");
+  const cachePath = import_node_path27.default.join(codexHome, "models_cache.json");
   const cacheRaw = readTextIfExists(cachePath);
   if (cacheRaw) {
     try {
@@ -54669,7 +55069,7 @@ function readCodexFallbackModels() {
       );
     }
   }
-  for (const slug of readKnownGptSlugsFromTomlFile(import_node_path24.default.join(codexHome, "config.toml"))) {
+  for (const slug of readKnownGptSlugsFromTomlFile(import_node_path27.default.join(codexHome, "config.toml"))) {
     addBridgeModel(
       models,
       mapBridgeModel({
@@ -54683,11 +55083,11 @@ function readCodexFallbackModels() {
       })
     );
   }
-  const automationsDir = import_node_path24.default.join(codexHome, "automations");
+  const automationsDir = import_node_path27.default.join(codexHome, "automations");
   try {
-    for (const entry of import_node_fs17.default.readdirSync(automationsDir, { withFileTypes: true })) {
+    for (const entry of import_node_fs20.default.readdirSync(automationsDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      for (const slug of readKnownGptSlugsFromTomlFile(import_node_path24.default.join(automationsDir, entry.name, "automation.toml"))) {
+      for (const slug of readKnownGptSlugsFromTomlFile(import_node_path27.default.join(automationsDir, entry.name, "automation.toml"))) {
         addBridgeModel(
           models,
           mapBridgeModel({
@@ -54707,15 +55107,15 @@ function readCodexFallbackModels() {
   return [...models.values()];
 }
 function selfUpdateInboxItemId(offeredVersion) {
-  if (!offeredVersion) return `II-MCPUPD-${(0, import_node_crypto10.randomUUID)()}`;
+  if (!offeredVersion) return `II-MCPUPD-${(0, import_node_crypto11.randomUUID)()}`;
   if (/^[A-Za-z0-9._-]+$/.test(offeredVersion)) return `II-MCPUPD-${offeredVersion}`;
-  const hash3 = import_node_crypto10.default.createHash("sha256").update(offeredVersion).digest("hex").slice(0, 10);
+  const hash3 = import_node_crypto11.default.createHash("sha256").update(offeredVersion).digest("hex").slice(0, 10);
   return `II-MCPUPD-${offeredVersion.replace(/[^A-Za-z0-9._-]/g, "-")}-${hash3}`;
 }
 function neutralCheckoutCwd(stateDir) {
-  const dir = import_node_path24.default.join(stateDir, "no-checkout");
+  const dir = import_node_path27.default.join(stateDir, "no-checkout");
   try {
-    import_node_fs17.default.mkdirSync(dir, { recursive: true });
+    import_node_fs20.default.mkdirSync(dir, { recursive: true });
   } catch {
   }
   return dir;
@@ -55225,7 +55625,7 @@ async function runOrphanWorktreeSweep(client, opts) {
   const cutoff = Date.now() - worktreeRetentionMs();
   const isReapable = (worktreePath) => {
     try {
-      return import_node_fs17.default.statSync(worktreePath).mtimeMs < cutoff;
+      return import_node_fs20.default.statSync(worktreePath).mtimeMs < cutoff;
     } catch {
       return false;
     }
@@ -55263,8 +55663,8 @@ async function runOrphanWorktreeSweep(client, opts) {
   }
 }
 function readStateDir() {
-  if (process.env.CODEX_HOME) return import_node_path24.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
-  return import_node_path24.default.join(import_node_os11.default.homedir(), ".mrrlin", "director-bridge");
+  if (process.env.CODEX_HOME) return import_node_path27.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
+  return import_node_path27.default.join(import_node_os12.default.homedir(), ".mrrlin", "director-bridge");
 }
 function readAllowedOrigins() {
   const raw = (process.env.MRRLIN_DIRECTOR_BRIDGE_ALLOWED_ORIGINS ?? "").trim();
@@ -55339,7 +55739,7 @@ function createBridgeRequestListener(opts) {
         res.end(JSON.stringify({ ok: false, error: "Origin not allowed." }));
         return;
       }
-      const nonce = import_node_crypto10.default.randomBytes(16).toString("base64url");
+      const nonce = import_node_crypto11.default.randomBytes(16).toString("base64url");
       res.writeHead(200, { "content-type": "application/json" });
       res.end(JSON.stringify({ ok: true, wsUrl: `ws://${host}:${port}/ws`, token, nonce }));
       return;
@@ -55638,7 +56038,7 @@ function createBridgeMessageHandler(deps) {
       }
     }
     socket.on("message", async (data) => {
-      const spanId = import_node_crypto10.default.randomUUID();
+      const spanId = import_node_crypto11.default.randomUUID();
       if (logCtx) {
         logCtx.span.id = spanId;
         logCtx.span.at = Date.now();
@@ -55700,7 +56100,7 @@ function createBridgeMessageHandler(deps) {
           sendForSpan({ type: "checkout-state", ok: false, error: { code: "invalid_input", fields: { projectSlug: "required" } } });
           return;
         }
-        const state = readCheckoutState(deps.checkoutRegistry, projectSlug, import_node_os11.default.hostname());
+        const state = readCheckoutState(deps.checkoutRegistry, projectSlug, import_node_os12.default.hostname());
         if (!state) {
           sendForSpan({ type: "checkout-state", ok: false, error: { code: "checkout_missing" } });
           return;
@@ -55732,7 +56132,7 @@ function createBridgeMessageHandler(deps) {
         const result = registerCheckout(
           deps.checkoutRegistry,
           { projectSlug, path: typeof msg.path === "string" ? msg.path : "", repo },
-          import_node_os11.default.hostname()
+          import_node_os12.default.hostname()
         );
         if (!result.ok) {
           sendForSpan({ type: "checkout-register", ok: false, error: { code: result.code, detail: result.detail } });
@@ -56218,7 +56618,7 @@ function createBridgeMessageHandler(deps) {
       thread.inFlight = true;
       pendingTurnSessions.delete(directorSessionId);
       thread.replay = createReplayBuffer({
-        turnId: (0, import_node_crypto10.randomUUID)(),
+        turnId: (0, import_node_crypto11.randomUUID)(),
         spanId,
         ...deps.retentionMs !== void 0 ? { retentionMs: deps.retentionMs } : {},
         ...deps.ackLingerMs !== void 0 ? { ackLingerMs: deps.ackLingerMs } : {}
@@ -56799,8 +57199,8 @@ async function startDirectorBridge() {
     codexCwd: config2.codexCwd,
     codexExecutable: config2.codexExecutable,
     checkoutRegistry,
-    worktreeRoot: import_node_path24.default.join(config2.stateDir, "worktrees"),
-    locksDir: import_node_path24.default.join(config2.stateDir, "locks"),
+    worktreeRoot: import_node_path27.default.join(config2.stateDir, "worktrees"),
+    locksDir: import_node_path27.default.join(config2.stateDir, "locks"),
     // Wire the executor server for code-execution runs. Each run gets its own provider process
     // (app-server for codex, a resident CLI child for claude) at the run worktree, running
     // UNRESTRICTED from the real operator config (owner no-sandbox decision — auth + mrrlin MCP
@@ -56844,13 +57244,13 @@ async function startDirectorBridge() {
         // egressDomains is retained in the seam signature (verification-turn.ts still computes the
         // env host) but no longer constrains anything — the executor is unrestricted.
         startSandbox: async (_egressDomains, providerId) => {
-          const cwd = import_node_fs17.default.mkdtempSync(import_node_path24.default.join(import_node_os11.default.tmpdir(), "mrrlin-verify-"));
+          const cwd = import_node_fs20.default.mkdtempSync(import_node_path27.default.join(import_node_os12.default.tmpdir(), "mrrlin-verify-"));
           let executor;
           try {
             executor = await startExecutorServer({ worktree: cwd, provider: providerId });
           } catch (error51) {
             try {
-              import_node_fs17.default.rmSync(cwd, { recursive: true, force: true });
+              import_node_fs20.default.rmSync(cwd, { recursive: true, force: true });
             } catch {
             }
             throw error51;
@@ -56861,7 +57261,7 @@ async function startDirectorBridge() {
             dispose: () => {
               executor.dispose();
               try {
-                import_node_fs17.default.rmSync(cwd, { recursive: true, force: true });
+                import_node_fs20.default.rmSync(cwd, { recursive: true, force: true });
               } catch {
               }
             }
@@ -56890,7 +57290,7 @@ async function startDirectorBridge() {
   };
   const sessionSinks = createSessionSinkRegistry();
   const tombstones = /* @__PURE__ */ new Map();
-  const bridgeInstanceId = (0, import_node_crypto10.randomUUID)();
+  const bridgeInstanceId = (0, import_node_crypto11.randomUUID)();
   const asyncConsumerDeps = {
     client,
     run: wrappedTurnLock.run,
@@ -57041,7 +57441,7 @@ async function startDirectorBridge() {
   const relayUrl = process.env.MRRLIN_RELAY_URL?.trim();
   const relayConfigured = Boolean(agentSecret && relayUrl);
   const buildReseedPrefix = async (args) => {
-    const refuse = (reason) => {
+    const refuse2 = (reason) => {
       bridgeLogger.logOut({
         spanId: "reseed",
         sessionId: args.directorSessionId,
@@ -57050,8 +57450,8 @@ async function startDirectorBridge() {
       });
       return NO_HISTORY_BLOCK;
     };
-    if (!resolveBridgeLogEnabled()) return refuse("log-disabled");
-    if (!resolvePromptsEnabled()) return refuse("prompts-not-logged");
+    if (!resolveBridgeLogEnabled()) return refuse2("log-disabled");
+    if (!resolvePromptsEnabled()) return refuse2("prompts-not-logged");
     const retentionWindowMs = readEnvInt("MRRLIN_LOG_RETENTION_AGE_DAYS", 30) * 864e5;
     const reseedWindowMs = Math.min(config2.idleThreadTtlMs, retentionWindowMs);
     if (reseedWindowMs < config2.idleThreadTtlMs) {
@@ -57068,15 +57468,15 @@ async function startDirectorBridge() {
     }
     const files = dayFilesInWindow(/* @__PURE__ */ new Date(), reseedWindowMs);
     const sessionIds = [args.directorSessionId, ...args.priorSessionIds];
-    const { lines: lines2, missingFiles } = await readSessionRows(import_node_path24.default.join(config2.stateDir, "logs"), files, sessionIds);
+    const { lines: lines2, missingFiles } = await readSessionRows(import_node_path27.default.join(config2.stateDir, "logs"), files, sessionIds);
     const { items, skipped: skipped2 } = extractItems(lines2, sessionIds);
-    if (items.length === 0) return refuse("no-rows");
+    if (items.length === 0) return refuse2("no-rows");
     const budget = Math.max(0, Math.min(config2.reseedMaxTokens, config2.turnMaxTokens - args.otherBytes));
     const block = renderReseedBlock(items, {
       maxTokens: budget,
       minConversationalItems: config2.reseedMinItems
     });
-    if (!block) return refuse("below-minimum-after-truncation");
+    if (!block) return refuse2("below-minimum-after-truncation");
     bridgeLogger.logOut({
       spanId: "reseed",
       sessionId: args.directorSessionId,
@@ -57165,7 +57565,7 @@ async function startDirectorBridge() {
   const bridgeLogger = createBridgeLogger(config2.stateDir, process.env);
   let bridgeBinShaShort = "unknown00000";
   try {
-    bridgeBinShaShort = import_node_crypto10.default.createHash("sha256").update(import_node_fs17.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
+    bridgeBinShaShort = import_node_crypto11.default.createHash("sha256").update(import_node_fs20.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
   } catch {
   }
   attachBridgeWss(server, {
@@ -57301,8 +57701,8 @@ async function startDirectorBridge() {
       );
       void runOrphanWorktreeSweep(client, {
         checkoutRegistry,
-        worktreeRoot: import_node_path24.default.join(config2.stateDir, "worktrees"),
-        locksDir: import_node_path24.default.join(config2.stateDir, "locks")
+        worktreeRoot: import_node_path27.default.join(config2.stateDir, "worktrees"),
+        locksDir: import_node_path27.default.join(config2.stateDir, "locks")
       });
       {
         const { retainedBuffers, retainedBytes, tombstonesRemoved } = sweepReplayBuffers(threads, tombstones, {
@@ -57610,7 +58010,7 @@ function timingSafeTokenEqual(provided, expected) {
   const a = Buffer.from(provided);
   const b = Buffer.from(expected);
   if (a.length !== b.length) return false;
-  return import_node_crypto10.default.timingSafeEqual(a, b);
+  return import_node_crypto11.default.timingSafeEqual(a, b);
 }
 function readDispatchBody(req) {
   return new Promise((resolve, reject) => {
@@ -57632,15 +58032,15 @@ function readDispatchBody(req) {
 function readOrCreateBridgeToken(stateDir) {
   const explicit = (process.env.MRRLIN_DIRECTOR_BRIDGE_TOKEN ?? "").trim();
   if (explicit) return explicit;
-  const tokenPath = import_node_path24.default.join(stateDir, "token.txt");
+  const tokenPath = import_node_path27.default.join(stateDir, "token.txt");
   try {
-    const existing = import_node_fs17.default.readFileSync(tokenPath, "utf8").trim();
+    const existing = import_node_fs20.default.readFileSync(tokenPath, "utf8").trim();
     if (existing) return existing;
   } catch {
   }
-  import_node_fs17.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
-  const token = import_node_crypto10.default.randomBytes(32).toString("base64url");
-  import_node_fs17.default.writeFileSync(tokenPath, `${token}
+  import_node_fs20.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
+  const token = import_node_crypto11.default.randomBytes(32).toString("base64url");
+  import_node_fs20.default.writeFileSync(tokenPath, `${token}
 `, { mode: 384 });
   return token;
 }
@@ -61028,17 +61428,17 @@ var StdioServerTransport = class {
 };
 
 // src/tools.ts
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 var import_promises10 = require("node:fs/promises");
-var import_node_path27 = __toESM(require("node:path"), 1);
-var import_node_os12 = __toESM(require("node:os"), 1);
+var import_node_path30 = __toESM(require("node:path"), 1);
+var import_node_os13 = __toESM(require("node:os"), 1);
 
 // ../../packages/wiki/dist/index.js
 var import_promises8 = __toESM(require("node:fs/promises"), 1);
-var import_node_path25 = __toESM(require("node:path"), 1);
+var import_node_path28 = __toESM(require("node:path"), 1);
 var INCLUDED_DOC_FOLDERS = /* @__PURE__ */ new Set(["_meta", "explanation", "how-to", "reference", "sdd", "tutorials"]);
 function toPosixPath(input) {
-  return input.split(import_node_path25.default.sep).join("/");
+  return input.split(import_node_path28.default.sep).join("/");
 }
 function slugifyWikiSegment(input) {
   return input.trim().toLowerCase().replace(/`/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -61052,12 +61452,12 @@ async function pathExists3(input) {
   }
 }
 async function findWorkspaceRoot(start = process.cwd()) {
-  let current2 = import_node_path25.default.resolve(start);
+  let current2 = import_node_path28.default.resolve(start);
   while (true) {
-    if (await pathExists3(import_node_path25.default.join(current2, "pnpm-workspace.yaml")) && await pathExists3(import_node_path25.default.join(current2, "docs"))) {
+    if (await pathExists3(import_node_path28.default.join(current2, "pnpm-workspace.yaml")) && await pathExists3(import_node_path28.default.join(current2, "docs"))) {
       return current2;
     }
-    const parent = import_node_path25.default.dirname(current2);
+    const parent = import_node_path28.default.dirname(current2);
     if (parent === current2) {
       throw new Error(`Unable to find Mrrlin workspace root from ${start}`);
     }
@@ -61066,28 +61466,28 @@ async function findWorkspaceRoot(start = process.cwd()) {
 }
 async function resolveDocsRoot(input) {
   if (input) {
-    return import_node_path25.default.resolve(input);
+    return import_node_path28.default.resolve(input);
   }
   if (process.env.MRRLIN_DOCS_ROOT) {
-    return import_node_path25.default.resolve(process.env.MRRLIN_DOCS_ROOT);
+    return import_node_path28.default.resolve(process.env.MRRLIN_DOCS_ROOT);
   }
-  return import_node_path25.default.join(await findWorkspaceRoot(), "docs");
+  return import_node_path28.default.join(await findWorkspaceRoot(), "docs");
 }
 async function resolveIndexPath(input) {
   if (input) {
-    return import_node_path25.default.resolve(input);
+    return import_node_path28.default.resolve(input);
   }
   if (process.env.MRRLIN_WIKI_INDEX_PATH) {
-    return import_node_path25.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
+    return import_node_path28.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
   }
   const workspaceRoot = await findWorkspaceRoot();
-  return import_node_path25.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
+  return import_node_path28.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
 }
 async function walkMarkdownFiles(root, dir = root) {
   const entries = await import_promises8.default.readdir(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const absolute = import_node_path25.default.join(dir, entry.name);
+    const absolute = import_node_path28.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkMarkdownFiles(root, absolute));
       continue;
@@ -61106,7 +61506,7 @@ function parseTitle(markdown, sourcePath) {
   return title;
 }
 function documentFromFile(docsRoot, absolutePath, markdown) {
-  const relativePath = toPosixPath(import_node_path25.default.relative(docsRoot, absolutePath));
+  const relativePath = toPosixPath(import_node_path28.default.relative(docsRoot, absolutePath));
   const [section, fileName] = relativePath.split("/");
   if (!section || !fileName || !INCLUDED_DOC_FOLDERS.has(section)) {
     return null;
@@ -61457,15 +61857,17 @@ async function pickPanel(input, deps) {
   const agents = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
   return { ok: true, agents };
 }
-async function dispatchHead(agentId, prompt, timeoutMs, deps) {
-  const spawn4 = deps?.spawn ?? import_node_child_process17.spawn;
-  const { command, prefixArgs } = resolveExternalAgentsCliInvocation(deps?.externalAgentsBin);
-  const args = ["dispatch", agentId, "--json", prompt];
-  const r = await runExternalAgents(command, [...prefixArgs, ...args], "dispatch", timeoutMs, spawn4);
-  if (r.error) return { ok: false, error: r.error };
-  const lines2 = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+function dispatchUsage(parsed) {
+  const readCount3 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+  const inputTokens = readCount3(parsed.tokens_in);
+  const outputTokens = readCount3(parsed.tokens_out);
+  if (inputTokens === null && outputTokens === null) return null;
+  return { inputTokens, cachedInputTokens: null, cacheWriteInputTokens: null, outputTokens };
+}
+function parseDispatch(agentId, stdout, exitCode) {
+  const lines2 = stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
   const jsonLine = [...lines2].reverse().find((l) => l[0] === "{");
-  if (!jsonLine) return { ok: false, error: `dispatch ${agentId}: no JSON on stdout (exit ${r.code})` };
+  if (!jsonLine) return { ok: false, error: `dispatch ${agentId}: no JSON on stdout (exit ${exitCode})` };
   let parsed;
   try {
     parsed = JSON.parse(jsonLine);
@@ -61478,7 +61880,16 @@ async function dispatchHead(agentId, prompt, timeoutMs, deps) {
   if (typeof parsed.text !== "string" || parsed.text.trim() === "") {
     return { ok: false, error: `dispatch ${agentId}: empty text on success` };
   }
-  return { ok: true, text: parsed.text };
+  const usage = dispatchUsage(parsed);
+  return { ok: true, text: parsed.text, usage };
+}
+async function dispatchHead(agentId, prompt, timeoutMs, deps) {
+  const spawn4 = deps?.spawn ?? import_node_child_process17.spawn;
+  const { command, prefixArgs } = resolveExternalAgentsCliInvocation(deps?.externalAgentsBin);
+  const args = ["dispatch", agentId, "--json", prompt];
+  const r = await runExternalAgents(command, [...prefixArgs, ...args], "dispatch", timeoutMs, spawn4);
+  if (r.error) return { ok: false, error: r.error };
+  return parseDispatch(agentId, r.stdout, r.code);
 }
 async function buildMultiHeadRunner(input, deps) {
   const pickOnce = () => pickPanel(
@@ -61722,6 +62133,245 @@ async function resolveActivePanel(input, deps) {
   }
 }
 
+// src/delivery/wiki.ts
+async function deliverToWiki(client, projectSlug, payload) {
+  if (payload.operation === "create") return client.createWikiPage(projectSlug, payload.page);
+  return client.updateWikiPage(projectSlug, payload.pageId, payload.patch);
+}
+
+// src/delivery/git.ts
+async function deliverToGit(client, projectSlug, payload) {
+  if (payload.operation === "branch") {
+    return client.createGithubBranch(projectSlug, { baseBranch: payload.baseBranch, branchName: payload.branchName });
+  }
+  return client.createGithubPullRequest(projectSlug, {
+    baseBranch: payload.baseBranch,
+    body: payload.body,
+    draft: payload.draft,
+    headBranch: payload.headBranch,
+    title: payload.title
+  });
+}
+
+// src/delivery/index.ts
+async function deliverThroughCapability(client, input) {
+  if (resolveKindCapability(input.artifactKind) === null) {
+    return { ok: false, reason: "blocked_kind" };
+  }
+  let resolution;
+  try {
+    resolution = await client.resolveDeliveryForArtifactKind(
+      input.projectSlug,
+      input.artifactKind,
+      input.taskProjectSlug,
+      input.taskId ?? void 0
+    );
+  } catch {
+    return { ok: false, reason: "transport_error" };
+  }
+  if (!resolution.ok) {
+    return { ok: false, reason: resolution.reason };
+  }
+  const { route, verdict } = resolution;
+  if (verdict === "silent") {
+    return proceedToDestination(client, route, input);
+  }
+  if (verdict === "ask_once") {
+    return handleAskOnce(client, route, input);
+  }
+  if (verdict === "window") {
+    return handleWindow(client, route, input);
+  }
+  if (verdict === "approval") {
+    return handleApproval(client, route, input);
+  }
+  await recordUse(client, route, input, "refused");
+  return { ok: false, reason: "gate_refused" };
+}
+async function proceedToDestination(client, route, input) {
+  try {
+    const result = await callDestination(client, input.taskProjectSlug, route.capability, input.payload);
+    const recorded = await recordUse(client, route, input, "ok");
+    return { ok: true, use: recorded, result };
+  } catch {
+    await recordUse(client, route, input, "error");
+    return { ok: false, reason: "delivery_failed" };
+  }
+}
+async function refuse(client, route, input) {
+  await recordUse(client, route, input, "refused");
+  return { ok: false, reason: "gate_refused" };
+}
+async function handleAskOnce(client, route, input) {
+  const groupId = `capability:ask-once:${input.taskProjectSlug}:${route.serverId}`;
+  try {
+    await client.createInboxItem(input.taskProjectSlug, {
+      id: `II-capability-ask-once-${input.taskProjectSlug}-${route.serverId}`,
+      kind: "question",
+      origin: "capability",
+      groupId,
+      body: `The first write to ${route.serverId} (via ${route.toolName}) needs a one-time confirmation before it can proceed.`,
+      taskId: input.taskId
+    });
+  } catch {
+  }
+  return refuse(client, route, input);
+}
+async function alreadyConsumed(client, route, input, after) {
+  let uses;
+  try {
+    uses = await client.listCapabilityUses(input.taskProjectSlug);
+  } catch {
+    return true;
+  }
+  const afterMs = Date.parse(after);
+  if (!Number.isFinite(afterMs)) return true;
+  return uses.some((use) => {
+    if (use.serverId !== route.serverId || use.toolName !== route.toolName || use.taskId !== input.taskId || use.outcome !== "ok") {
+      return false;
+    }
+    const useAtMs = Date.parse(use.at);
+    if (!Number.isFinite(useAtMs)) return true;
+    return useAtMs > afterMs;
+  });
+}
+async function handleApproval(client, route, input) {
+  const scopeId = input.runId ?? input.taskId;
+  if (scopeId === null) {
+    return refuse(client, route, input);
+  }
+  const groupId = `capability:approval:${scopeId}:${route.serverId}:${route.toolName}`;
+  const id = `II-capability-approval-${scopeId}-${route.serverId}-${route.toolName}`;
+  let items;
+  try {
+    items = await client.listInboxItems(input.taskProjectSlug, { groupId });
+  } catch {
+    return refuse(client, route, input);
+  }
+  const existing = items[0];
+  if (!existing) {
+    try {
+      await client.createInboxItem(input.taskProjectSlug, {
+        id,
+        kind: "question",
+        origin: "capability",
+        groupId,
+        body: `Approve ${route.toolName} on ${route.serverId}?`,
+        taskId: input.taskId
+      });
+    } catch {
+    }
+    return refuse(client, route, input);
+  }
+  if (existing.status !== "approved") {
+    return refuse(client, route, input);
+  }
+  if (existing.decidedAt === null) {
+    return refuse(client, route, input);
+  }
+  if (await alreadyConsumed(client, route, input, existing.decidedAt)) {
+    return refuse(client, route, input);
+  }
+  return proceedToDestination(client, route, input);
+}
+async function handleWindow(client, route, input) {
+  if (input.taskId === null) {
+    return refuse(client, route, input);
+  }
+  const taskId = input.taskId;
+  const scopeId = input.runId ?? taskId;
+  const groupId = `capability:window:${scopeId}:${route.serverId}:${route.toolName}`;
+  const id = `II-capability-window-${scopeId}-${route.serverId}-${route.toolName}`;
+  let items;
+  try {
+    items = await client.listInboxItems(input.taskProjectSlug, { groupId });
+  } catch {
+    return refuse(client, route, input);
+  }
+  const existing = items[0];
+  if (!existing) {
+    try {
+      await client.createInboxItem(input.taskProjectSlug, {
+        id,
+        kind: "question",
+        origin: "capability",
+        groupId,
+        body: `Waiting for the ${route.toolName} window on ${route.serverId} to elapse.`,
+        taskId
+      });
+    } catch {
+    }
+    await extendFollowUpAt(client, input.taskProjectSlug, taskId);
+    return refuse(client, route, input);
+  }
+  if (existing.status === "rejected") {
+    return refuse(client, route, input);
+  }
+  let task;
+  try {
+    task = await client.getTask(input.taskProjectSlug, taskId);
+  } catch {
+    return refuse(client, route, input);
+  }
+  const elapsed = task.followUpAt !== null && Date.parse(task.followUpAt) <= Date.now();
+  if (!elapsed) {
+    return refuse(client, route, input);
+  }
+  if (await alreadyConsumed(client, route, input, existing.createdAt)) {
+    return refuse(client, route, input);
+  }
+  const result = await proceedToDestination(client, route, input);
+  if (result.ok) {
+    try {
+      await client.decideInboxItem(input.taskProjectSlug, existing.id, { verdict: "acknowledged", decidedBy: "system" });
+    } catch {
+    }
+  }
+  return result;
+}
+async function extendFollowUpAt(client, taskProjectSlug, taskId) {
+  try {
+    const task = await client.getTask(taskProjectSlug, taskId);
+    const existingMs = task.followUpAt !== null ? Date.parse(task.followUpAt) : -Infinity;
+    const candidateMs = Date.now() + 5 * 60 * 1e3;
+    if (candidateMs > existingMs) {
+      await client.updateTask(taskProjectSlug, taskId, { followUpAt: new Date(candidateMs).toISOString() });
+    }
+  } catch {
+  }
+}
+async function recordUse(client, route, input, outcome) {
+  try {
+    return await client.recordCapabilityUse(input.taskProjectSlug, {
+      serverId: route.serverId,
+      toolName: route.toolName,
+      taskId: input.taskId,
+      outcome
+    });
+  } catch {
+    return null;
+  }
+}
+async function callDestination(client, projectSlug, capability, payload) {
+  const operation = isRecord4(payload) ? payload.operation : void 0;
+  if (capability === "wiki") {
+    if (operation !== "create" && operation !== "update") {
+      throw new Error(`callDestination: payload.operation "${String(operation)}" is not valid for wiki`);
+    }
+    return deliverToWiki(client, projectSlug, payload);
+  }
+  if (capability === "git") {
+    if (operation !== "branch" && operation !== "pull_request") {
+      throw new Error(`callDestination: payload.operation "${String(operation)}" is not valid for git`);
+    }
+    return deliverToGit(client, projectSlug, payload);
+  }
+  throw new Error(`callDestination: no destination wired for capability "${capability}"`);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+
 // src/decision-consensus.ts
 var ANCHOR_TIMEOUT_MS = Number(process.env["MRRLIN_DECISION_TIMEOUT_MS"] ?? 9e4);
 var PICK_TIMEOUT_MS3 = 15e3;
@@ -61863,7 +62513,7 @@ async function runDecisionConsensus(input, deps) {
 }
 
 // src/async-tools/consensus.ts
-var import_node_crypto11 = require("node:crypto");
+var import_node_crypto12 = require("node:crypto");
 
 // src/consensus/question-similarity.ts
 var SUPPRESSION_SIMILARITY_THRESHOLD = 0.6;
@@ -62059,6 +62709,10 @@ async function runNativeSpecGate(ctx, input, builders = defaultNativeSpecGateBui
     specPageId: input.pageId,
     cwd: ctx.cwd,
     codexExecutable: ctx.codexExecutable,
+    // Where the gate records what each of its provider calls cost. This is the only one of the
+    // four gate-deps call sites that holds a stateDir today; without it the recorder is a no-op,
+    // so the spec gate is the one whose cost is actually observable.
+    stateDir: ctx.stateDir,
     extraHeadCount: input.extraHeads?.length ?? 0,
     // model-tier-planning-and-arbiter task 1.21: the seat minted at the async-job claim.
     seat: ctx.seat
@@ -62139,9 +62793,9 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
     }
     if (taskId) {
       const scopeId = taskId;
-      const groupId = toFile.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto11.createHash)("sha256").update(toFile.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
+      const groupId = toFile.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto12.createHash)("sha256").update(toFile.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
       for (const clarification of toFile) {
-        const id = `II-${scopeId}-gate-${(0, import_node_crypto11.createHash)("sha256").update(clarification.rawQuestion).digest("hex").slice(0, 10)}`;
+        const id = `II-${scopeId}-gate-${(0, import_node_crypto12.createHash)("sha256").update(clarification.rawQuestion).digest("hex").slice(0, 10)}`;
         try {
           const questionOptions = buildGateQuestionOptions(clarification.rawQuestion, clarification.category);
           await ctx.client.createInboxItem(input.projectSlug, {
@@ -62159,9 +62813,9 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
       filedQuestionCount = toFile.length;
     } else if (planId) {
       const scopeId = planId;
-      const groupId = toFile.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto11.createHash)("sha256").update(toFile.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
+      const groupId = toFile.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto12.createHash)("sha256").update(toFile.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
       for (const clarification of toFile) {
-        const id = `II-${scopeId}-gate-${(0, import_node_crypto11.createHash)("sha256").update(clarification.rawQuestion).digest("hex").slice(0, 10)}`;
+        const id = `II-${scopeId}-gate-${(0, import_node_crypto12.createHash)("sha256").update(clarification.rawQuestion).digest("hex").slice(0, 10)}`;
         try {
           const questionOptions = buildGateQuestionOptions(clarification.rawQuestion, clarification.category);
           await ctx.client.createInboxItem(input.projectSlug, {
@@ -62185,7 +62839,7 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
       taskId: page.taskId ?? null
     });
     const reviewHash = domainScopedReviewHash2(page.contentHash, domain2);
-    const baseBlockItemId = `II-${taskId}-gateblock-${(0, import_node_crypto11.createHash)("sha256").update(reviewHash).digest("hex").slice(0, 10)}`;
+    const baseBlockItemId = `II-${taskId}-gateblock-${(0, import_node_crypto12.createHash)("sha256").update(reviewHash).digest("hex").slice(0, 10)}`;
     const reviewAgainAvailable = !taskInboxItems.some(
       (item) => item.id === baseBlockItemId && item.status !== "pending" && item.answer === REVIEW_AGAIN_ANSWER
     );
@@ -62757,17 +63411,17 @@ var intentCheckDescriptor = createIntentCheckDescriptor();
 
 // src/evidence/assembler.ts
 var import_promises9 = require("node:fs/promises");
-var import_node_path26 = require("node:path");
+var import_node_path29 = require("node:path");
 function evidenceDedupKey(sessionId, reportId) {
   return `${sessionId}:${reportId}`;
 }
-function isRecord4(v) {
+function isRecord5(v) {
   return v !== null && typeof v === "object";
 }
 async function readDayLines(stateDir, day, sessionId) {
   let raw;
   try {
-    raw = await (0, import_promises9.readFile)((0, import_node_path26.join)(stateDir, "logs", `bridge-${day}.jsonl`), "utf8");
+    raw = await (0, import_promises9.readFile)((0, import_node_path29.join)(stateDir, "logs", `bridge-${day}.jsonl`), "utf8");
   } catch {
     return [];
   }
@@ -62780,7 +63434,7 @@ async function readDayLines(stateDir, day, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord4(rec) || !isRecord4(rec.payload)) continue;
+    if (!isRecord5(rec) || !isRecord5(rec.payload)) continue;
     if (rec.payload.directorSessionId !== sessionId) continue;
     kept.push(rec);
   }
@@ -62841,7 +63495,7 @@ async function assembleEvidence(stateDir, sessionId, reportId, gateCtx) {
   }
   let windowPruned = false;
   try {
-    const raw = await (0, import_promises9.readFile)((0, import_node_path26.join)(stateDir, "logs", ".pruned.jsonl"), "utf8");
+    const raw = await (0, import_promises9.readFile)((0, import_node_path29.join)(stateDir, "logs", ".pruned.jsonl"), "utf8");
     outer: for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
       let rec;
@@ -62850,7 +63504,7 @@ async function assembleEvidence(stateDir, sessionId, reportId, gateCtx) {
       } catch {
         continue;
       }
-      if (!isRecord4(rec) || !Array.isArray(rec.daysRemoved)) continue;
+      if (!isRecord5(rec) || !Array.isArray(rec.daysRemoved)) continue;
       for (const removedDay of rec.daysRemoved) {
         if (daysRead.includes(removedDay)) {
           windowPruned = true;
@@ -62907,7 +63561,7 @@ function createReportEvidenceDescriptor() {
 var reportEvidenceDescriptor = createReportEvidenceDescriptor();
 
 // src/async-tools/enqueue.ts
-var import_node_crypto12 = __toESM(require("node:crypto"), 1);
+var import_node_crypto13 = __toESM(require("node:crypto"), 1);
 async function enqueueAsyncTool(client, descriptor2, input) {
   if (descriptor2.cachedResult) {
     const cached2 = await descriptor2.cachedResult(client, input);
@@ -62920,7 +63574,7 @@ async function enqueueAsyncTool(client, descriptor2, input) {
   if (active) {
     return { status: "already_running", jobId: active.id, message: "Already running; will notify in inbox." };
   }
-  const jobId = `AJ-${import_node_crypto12.default.randomUUID()}`;
+  const jobId = `AJ-${import_node_crypto13.default.randomUUID()}`;
   try {
     await client.createAsyncJob(input.projectSlug, {
       id: jobId,
@@ -63952,6 +64606,20 @@ function pingAsyncWorkerDispatch(projectSlug, jobId) {
   }).catch(() => {
   });
 }
+async function deliverBuiltIn(client, projectSlug, artifactKind, payload) {
+  const result = await deliverThroughCapability(client, {
+    projectSlug,
+    taskProjectSlug: projectSlug,
+    artifactKind,
+    taskId: null,
+    runId: null,
+    payload
+  });
+  if (!result.ok) {
+    throw new McpToolCodedError(`CAPABILITY_${result.reason.toUpperCase()}`, `Delivery refused: ${result.reason}`);
+  }
+  return result.result;
+}
 function makeTool(client, name, fallbackCode, fallbackMessage, handler) {
   return {
     description: mcpToolDescriptions[name],
@@ -64121,19 +64789,24 @@ function createMrrlinTools(options) {
       "Unable to bind project repository.",
       async (c, { projectSlug, ...input }) => await c.bindProjectGithubRepo(projectSlug, input)
     ),
+    // Task 8.2: routed through deliverBuiltIn, not c.createGithubBranch directly. artifactKind
+    // "code_change" (not "page"): this tool is a generic git operation, not specifically about
+    // publishing a website page (design.md, "`page` routes to git, not the wiki") -- there is no
+    // dedicated page-publishing tool in this change's scope, so a task requiring "page" has no path
+    // through these generic tools today, an accepted limitation of the current scope.
     [mcpToolNames.createGithubBranch]: makeTool(
       client,
       mcpToolNames.createGithubBranch,
       "GITHUB_BRANCH_CREATE_FAILED",
       "Unable to create GitHub branch.",
-      async (c, { projectSlug, ...input }) => await c.createGithubBranch(projectSlug, input)
+      async (c, { projectSlug, ...input }) => await deliverBuiltIn(c, projectSlug, "code_change", { operation: "branch", ...input })
     ),
     [mcpToolNames.createGithubPullRequest]: makeTool(
       client,
       mcpToolNames.createGithubPullRequest,
       "GITHUB_PULL_REQUEST_CREATE_FAILED",
       "Unable to create GitHub pull request.",
-      async (c, { projectSlug, ...input }) => await c.createGithubPullRequest(projectSlug, input)
+      async (c, { projectSlug, ...input }) => await deliverBuiltIn(c, projectSlug, "code_change", { operation: "pull_request", ...input })
     ),
     [mcpToolNames.createPlan]: makeTool(
       client,
@@ -64198,12 +64871,13 @@ function createMrrlinTools(options) {
       "Unable to append task event.",
       async (c, { projectSlug, taskId, ...input }) => await c.appendTaskEvent(projectSlug, taskId, input)
     ),
+    // Task 8.2: routed through deliverBuiltIn, not c.createWikiPage directly.
     [mcpToolNames.createWikiPage]: makeTool(
       client,
       mcpToolNames.createWikiPage,
       "WIKI_PAGE_CREATE_FAILED",
       "Unable to create wiki page.",
-      async (c, { projectSlug, ...input }) => await c.createWikiPage(projectSlug, input)
+      async (c, { projectSlug, ...input }) => await deliverBuiltIn(c, projectSlug, "document", { operation: "create", page: input })
     ),
     [mcpToolNames.deleteTaskDependency]: makeTool(
       client,
@@ -64386,12 +65060,13 @@ function createMrrlinTools(options) {
       "Unable to close task as won't-do.",
       async (c, { projectSlug, taskId, reason }) => await c.closeTaskAsWontDo(projectSlug, taskId, reason)
     ),
+    // Task 8.2: routed through deliverBuiltIn, not c.updateWikiPage directly.
     [mcpToolNames.updateWikiPage]: makeTool(
       client,
       mcpToolNames.updateWikiPage,
       "WIKI_PAGE_UPDATE_FAILED",
       "Unable to update wiki page.",
-      async (c, { projectSlug, pageId, ...patch }) => await c.updateWikiPage(projectSlug, pageId, patch)
+      async (c, { projectSlug, pageId, ...patch }) => await deliverBuiltIn(c, projectSlug, "document", { operation: "update", pageId, patch })
     ),
     [mcpToolNames.markSpecReady]: makeTool(
       client,
@@ -64580,7 +65255,7 @@ function createMrrlinTools(options) {
       "PRODUCED_URL_RECORD_FAILED",
       "Unable to record produced URL.",
       async (c, { projectSlug, runId, url: url2, label }) => {
-        const id = `EA-pu-${(0, import_node_crypto13.randomBytes)(4).toString("hex")}`;
+        const id = `EA-pu-${(0, import_node_crypto14.randomBytes)(4).toString("hex")}`;
         const payload = label ? { url: url2, label } : { url: url2 };
         return await c.appendExecutionArtifact(projectSlug, runId, {
           id,
@@ -64654,7 +65329,7 @@ function createMrrlinTools(options) {
       "ARTIFACT_FILE_UPLOAD_FAILED",
       "Unable to upload artifact file.",
       async (c, { projectSlug, path: filePath, class: artifactClass, taskId, runId, description }) => {
-        const extension2 = import_node_path27.default.extname(filePath).toLowerCase();
+        const extension2 = import_node_path30.default.extname(filePath).toLowerCase();
         const contentType = ARTIFACT_EXTENSION_TYPES[extension2];
         if (!contentType) {
           throw new McpToolCodedError(
@@ -64682,7 +65357,7 @@ function createMrrlinTools(options) {
             "Artifact exceeds 5MB; split or summarize instead."
           );
         }
-        const filename = import_node_path27.default.basename(filePath);
+        const filename = import_node_path30.default.basename(filePath);
         return uploadArtifactBytes(c, {
           bytes: bytes3,
           class: artifactClass,
@@ -64707,7 +65382,7 @@ function createMrrlinTools(options) {
             `Invalid filename '${filename}'; provide a bare filename with no path separators or '..'.`
           );
         }
-        const extension2 = import_node_path27.default.extname(filename).toLowerCase();
+        const extension2 = import_node_path30.default.extname(filename).toLowerCase();
         const contentType = ARTIFACT_EXTENSION_TYPES[extension2];
         if (!contentType) {
           throw new McpToolCodedError(
@@ -64781,9 +65456,9 @@ function createMrrlinTools(options) {
       "LOCAL_CHECKOUT_REGISTER_FAILED",
       "Unable to register local checkout.",
       async (_c, { projectSlug, path: checkoutPath, repo }) => {
-        const stateDir = process.env.CODEX_HOME ? import_node_path27.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path27.default.join(import_node_os12.default.homedir(), ".mrrlin", "director-bridge");
+        const stateDir = process.env.CODEX_HOME ? import_node_path30.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path30.default.join(import_node_os13.default.homedir(), ".mrrlin", "director-bridge");
         const registry3 = new CheckoutRegistry(stateDir);
-        const result = registerCheckout(registry3, { projectSlug, path: checkoutPath, repo }, import_node_os12.default.hostname());
+        const result = registerCheckout(registry3, { projectSlug, path: checkoutPath, repo }, import_node_os13.default.hostname());
         if (!result.ok) {
           const codeMap = {
             not_absolute: "LOCAL_CHECKOUT_PATH_NOT_ABSOLUTE",
@@ -65020,13 +65695,13 @@ function runSetCredential(args) {
 }
 
 // src/install-service.ts
-var import_node_os13 = __toESM(require("node:os"), 1);
-var import_node_fs18 = require("node:fs");
-var import_node_path28 = __toESM(require("node:path"), 1);
+var import_node_os14 = __toESM(require("node:os"), 1);
+var import_node_fs21 = require("node:fs");
+var import_node_path31 = __toESM(require("node:path"), 1);
 var SYSTEM_PATH_DIRS = ["/usr/bin", "/bin", "/usr/sbin", "/sbin"];
 function defaultHomeOwnerUid(home) {
   try {
-    return (0, import_node_fs18.statSync)(home).uid;
+    return (0, import_node_fs21.statSync)(home).uid;
   } catch {
     return null;
   }
@@ -65067,11 +65742,11 @@ function installService(deps) {
     deps.log(resolved.reason);
     return { ok: false };
   }
-  const home = deps.env.HOME ?? import_node_os13.default.homedir();
+  const home = deps.env.HOME ?? import_node_os14.default.homedir();
   const user = resolveBridgeUser({
     env: deps.env,
     home,
-    userInfo: deps.userInfo ?? (() => import_node_os13.default.userInfo()),
+    userInfo: deps.userInfo ?? (() => import_node_os14.default.userInfo()),
     homeOwnerUid: deps.homeOwnerUid ?? defaultHomeOwnerUid,
     log: deps.log
   });
@@ -65087,7 +65762,7 @@ function installService(deps) {
   const claudeBin = deps.which("claude");
   const resolvedBins = [...bins, claudeBin].filter((b) => b !== null);
   const pathEnv = Array.from(
-    /* @__PURE__ */ new Set([...resolvedBins.map((b) => import_node_path28.default.dirname(b)), ...SYSTEM_PATH_DIRS])
+    /* @__PURE__ */ new Set([...resolvedBins.map((b) => import_node_path31.default.dirname(b)), ...SYSTEM_PATH_DIRS])
   ).join(":");
   const apiBaseUrl = deps.env.MRRLIN_API_BASE_URL?.trim() || void 0;
   const staging = deps.env.MRRLIN_STAGING === "1" || !apiBaseUrl && bridgeUrlImpliesStaging(deps.env.MRRLIN_BRIDGE_URL);
@@ -65100,7 +65775,7 @@ function installService(deps) {
     staging,
     apiBaseUrl
   });
-  const ecoPath = import_node_path28.default.join(home, ".mrrlin", "ecosystem.config.cjs");
+  const ecoPath = import_node_path31.default.join(home, ".mrrlin", "ecosystem.config.cjs");
   deps.writeFile(ecoPath, text);
   const start = deps.runPm2(["startOrReload", ecoPath]);
   if (start.code !== 0) {
@@ -65152,13 +65827,13 @@ function uninstallService(deps) {
 
 // src/uninstall-codex.ts
 var import_promises11 = __toESM(require("node:fs/promises"), 1);
-var import_node_os14 = __toESM(require("node:os"), 1);
-var import_node_path29 = __toESM(require("node:path"), 1);
+var import_node_os15 = __toESM(require("node:os"), 1);
+var import_node_path32 = __toESM(require("node:path"), 1);
 var toml3 = __toESM(require_toml(), 1);
 function resolveCodexHome3(options) {
   if (options.codexHome) return options.codexHome;
   if (process.env.CODEX_HOME) return process.env.CODEX_HOME;
-  return import_node_path29.default.join(options.homeDir ?? import_node_os14.default.homedir(), ".codex");
+  return import_node_path32.default.join(options.homeDir ?? import_node_os15.default.homedir(), ".codex");
 }
 async function pathExists4(target) {
   try {
@@ -65171,7 +65846,7 @@ async function pathExists4(target) {
 var MRRLIN_BLOCK_RE = /(^|\n)\[mcp_servers\.(?:mrrlin(?:-browser)?|external-agents)(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
 async function uninstallCodex(options = {}) {
   const codexHome = resolveCodexHome3(options);
-  const configPath = import_node_path29.default.join(codexHome, "config.toml");
+  const configPath = import_node_path32.default.join(codexHome, "config.toml");
   const removePrompts = async () => uninstallPrompts(codexHome, options.promptNames ?? []);
   if (!await pathExists4(configPath)) {
     return { action: "missing", configPath, prompts: await removePrompts() };
@@ -65199,10 +65874,10 @@ async function uninstallCodex(options = {}) {
 }
 async function uninstallPrompts(codexHome, names) {
   if (names.length === 0) return [];
-  const promptsDir = import_node_path29.default.join(codexHome, "prompts");
+  const promptsDir = import_node_path32.default.join(codexHome, "prompts");
   const out = [];
   for (const name of names) {
-    const promptPath = import_node_path29.default.join(promptsDir, `${name}.md`);
+    const promptPath = import_node_path32.default.join(promptsDir, `${name}.md`);
     try {
       await import_promises11.default.unlink(promptPath);
       out.push({ name, action: "removed", promptPath });
@@ -65220,7 +65895,7 @@ async function uninstallPrompts(codexHome, names) {
 
 // src/extract/command.ts
 var import_promises12 = require("node:fs/promises");
-var import_node_path30 = require("node:path");
+var import_node_path33 = require("node:path");
 function parseArgs(args) {
   const map2 = /* @__PURE__ */ new Map();
   for (let i = 0; i < args.length; i++) {
@@ -65236,7 +65911,7 @@ function parseArgs(args) {
   }
   return map2;
 }
-function isRecord5(v) {
+function isRecord6(v) {
   return v !== null && typeof v === "object";
 }
 async function runExtract(args, deps) {
@@ -65257,7 +65932,7 @@ Missing required flag(s): ${missing.join(
   const days = await findSessionDays(deps.stateDir, sessionId);
   const matchingLines = [];
   for (const day of days) {
-    const logPath = (0, import_node_path30.join)(deps.stateDir, "logs", `bridge-${day}.jsonl`);
+    const logPath = (0, import_node_path33.join)(deps.stateDir, "logs", `bridge-${day}.jsonl`);
     let raw;
     try {
       raw = await (0, import_promises12.readFile)(logPath, "utf8");
@@ -65273,8 +65948,8 @@ Missing required flag(s): ${missing.join(
       } catch {
         continue;
       }
-      const payload = isRecord5(parsed) ? parsed.payload : void 0;
-      if (isRecord5(payload) && payload.directorSessionId === sessionId) {
+      const payload = isRecord6(parsed) ? parsed.payload : void 0;
+      if (isRecord6(payload) && payload.directorSessionId === sessionId) {
         matchingLines.push(line);
       }
     }
@@ -65357,16 +66032,16 @@ function bootHookStatus() {
   if (process.platform !== "darwin") return { status: "unknown" };
   const uid = process.getuid?.();
   if (uid === void 0 || uid === 0) return { status: "unknown" };
-  const home = process.env.HOME ?? (0, import_node_os15.homedir)();
-  const agents = import_node_path32.default.join(home, "Library", "LaunchAgents");
+  const home = process.env.HOME ?? (0, import_node_os16.homedir)();
+  const agents = import_node_path35.default.join(home, "Library", "LaunchAgents");
   const candidates = [
-    { label: "com.mrrlin.director-bridge", plist: import_node_path32.default.join(agents, "com.mrrlin.director-bridge.plist") },
-    { label: "com.PM2", plist: import_node_path32.default.join(agents, `pm2.${(0, import_node_os15.userInfo)().username}.plist`) }
+    { label: "com.mrrlin.director-bridge", plist: import_node_path35.default.join(agents, "com.mrrlin.director-bridge.plist") },
+    { label: "com.PM2", plist: import_node_path35.default.join(agents, `pm2.${(0, import_node_os16.userInfo)().username}.plist`) }
   ];
   for (const candidate of candidates) {
     const printed = (0, import_node_child_process18.spawnSync)("launchctl", ["print", `gui/${uid}/${candidate.label}`], { encoding: "utf8" });
     if (printed.status !== 0) continue;
-    if (!(0, import_node_fs19.existsSync)(candidate.plist)) continue;
+    if (!(0, import_node_fs22.existsSync)(candidate.plist)) continue;
     const out = printed.stdout ?? "";
     const runs = /^\s*runs\s*=\s*(\d+)/m.exec(out);
     const exitCode = /^\s*last exit code\s*=\s*(-?\d+)/m.exec(out);
@@ -65649,8 +66324,8 @@ async function main() {
         }
       }
       try {
-        const codexHome = process.env.CODEX_HOME ?? import_node_path32.default.join(process.env.HOME ?? (0, import_node_os15.homedir)(), ".codex");
-        (0, import_node_fs19.rmSync)(import_node_path32.default.join(codexHome, "prompts", "report-issue.md"), { force: true });
+        const codexHome = process.env.CODEX_HOME ?? import_node_path35.default.join(process.env.HOME ?? (0, import_node_os16.homedir)(), ".codex");
+        (0, import_node_fs22.rmSync)(import_node_path35.default.join(codexHome, "prompts", "report-issue.md"), { force: true });
       } catch {
       }
       const claudeResult = await installClaude({ binPath, force, serveEnv });
@@ -65711,8 +66386,8 @@ async function main() {
         env: process.env,
         cwd: process.cwd(),
         writeFile: (p, c) => {
-          (0, import_node_fs19.mkdirSync)(import_node_path32.default.dirname(p), { recursive: true, mode: 448 });
-          (0, import_node_fs19.writeFileSync)(p, c, { mode: 384 });
+          (0, import_node_fs22.mkdirSync)(import_node_path35.default.dirname(p), { recursive: true, mode: 448 });
+          (0, import_node_fs22.writeFileSync)(p, c, { mode: 384 });
         },
         runPm2: pm2Runner,
         which: whichBin,
@@ -65730,35 +66405,35 @@ async function main() {
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs19.rmSync)(p, { force: true });
+            (0, import_node_fs22.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: purge,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path32.default.join(process.env.HOME ?? (0, import_node_os15.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path35.default.join(process.env.HOME ?? (0, import_node_os16.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
         log: (m) => process.stderr.write(`[mrrlin-mcp uninstall-service] ${m}
 `)
       });
       return;
     }
     case "uninstall": {
-      const home = process.env.HOME ?? (0, import_node_os15.homedir)();
+      const home = process.env.HOME ?? (0, import_node_os16.homedir)();
       const log = (m) => process.stderr.write(`[mrrlin-mcp uninstall] ${m}
 `);
       uninstallService({
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs19.rmSync)(p, { force: true });
+            (0, import_node_fs22.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: true,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path32.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path35.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
         log
       });
       let codexOk = true;
@@ -65778,7 +66453,7 @@ async function main() {
         log(`codex config NOT modified: ${error51 instanceof Error ? error51.message : String(error51)}`);
       }
       try {
-        (0, import_node_fs19.rmSync)(import_node_path32.default.join(home, ".mrrlin"), { recursive: true, force: true });
+        (0, import_node_fs22.rmSync)(import_node_path35.default.join(home, ".mrrlin"), { recursive: true, force: true });
       } catch {
       }
       log("removed ~/.mrrlin");
@@ -65819,7 +66494,7 @@ ${HELP_TEXT}`);
   }
 }
 function resolveSelfBinPath() {
-  return import_node_path31.default.resolve(process.argv[1] ?? process.execPath);
+  return import_node_path34.default.resolve(process.argv[1] ?? process.execPath);
 }
 main().catch((error51) => {
   process.stderr.write(`mrrlin-mcp fatal error: ${error51 instanceof Error ? error51.message : String(error51)}