@akagilnc/pi-workflow-roles 0.1.3280 → 0.1.3353

package/dist/grok/production-host.js

@@ -2697,11 +2697,14 @@ var notaryOutputSchema = withInfrastructureFailureDeclaration(
   openToolObject(
     Type10.Object({
       status: Type10.Unknown({
-        description: "pass | bounce \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
+        description: "pass | bounce | escalate \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
       }),
       findings: Type10.Unknown({
-        description: "string[] findings\uFF0C\u968F pass \u6216 bounce \u7559\u5B58"
-      })
+        description: "string[] findings\uFF0C\u968F pass\u3001bounce \u6216 escalate \u7559\u5B58"
+      }),
+      reason: Type10.Optional(Type10.Unknown({
+        description: "status \u4E3A escalate \u65F6\u7684\u4E0A\u5448\u7406\u7531"
+      }))
     })
   )
 );
@@ -2726,6 +2729,9 @@ function projectLawfulNotaryOutput(value) {
     if (!Array.isArray(clone.findings)) clone.findings = asStringArray2(clone.findings);
     return clone;
   }
+  if (status === "escalate") {
+    return structuredClone(value);
+  }
   return void 0;
 }
 function retainNotarySubmission(value) {
@@ -2805,7 +2811,7 @@ function validateRecordedInspectorOutput(value) {
   } catch {
     throw new Error("Inspector output has no execution discriminator");
   }
-  if (status === "pass" || status === "bounce") {
+  if (status === "pass" || status === "bounce" || status === "escalate") {
     return value;
   }
   throw new Error("Inspector output has no execution discriminator");
@@ -4982,9 +4988,23 @@ function buildAuditEscalationResult(decision, deliveredOutput) {
   if (Object.hasOwn(decision, "decisionGate")) {
     auditOwned.auditDecisionGate = decision.decisionGate;
   }
+  if (Object.hasOwn(decision, "reason") && decision.reason !== void 0) {
+    auditOwned.reason = decision.reason;
+  }
+  if (Object.hasOwn(decision, "officer") && decision.officer !== void 0) {
+    auditOwned.officer = decision.officer;
+  }
+  if (Object.hasOwn(decision, "findings") && decision.findings !== void 0) {
+    auditOwned.findings = decision.findings;
+  }
   const deliveredFields = deliveredOutput !== void 0 && deliveredOutput !== null && typeof deliveredOutput === "object" && !Array.isArray(deliveredOutput) ? { ...deliveredOutput } : {};
   delete deliveredFields.conflicts;
   delete deliveredFields.auditDecisionGate;
+  if (Object.hasOwn(decision, "officer")) {
+    delete deliveredFields.reason;
+    delete deliveredFields.officer;
+    delete deliveredFields.findings;
+  }
   const result2 = {
     ...deliveredFields,
     ...auditOwned
@@ -4996,11 +5016,20 @@ function isAuditEscalationProjection(value) {
   if (!isAuditEscalationResult(value)) return false;
   return AUDIT_ESCALATION_LIVE_REGISTRY.has(value);
 }
-function humanDecisionText(result2) {
-  const lines = ["Human decision required: compliance audit escalation."];
+function humanDecisionText(decision, result2) {
+  const officer = Object.hasOwn(decision, "officer") ? decision.officer : void 0;
+  const lines = [
+    officer === void 0 ? "Human decision required: compliance audit escalation." : `Human decision required: ${officer} escalation.`
+  ];
+  if (officer !== void 0 && typeof result2.reason === "string") {
+    lines.push(`Reason: ${result2.reason}`);
+  }
   if (Array.isArray(result2.conflicts)) {
     lines.push("Conflicts:", ...result2.conflicts.map((conflict) => `- ${conflict}`));
   }
+  if (officer !== void 0 && Array.isArray(result2.findings) && result2.findings.length > 0) {
+    lines.push("Findings:", ...result2.findings.map((finding2) => `- ${finding2}`));
+  }
   const gate = result2.auditDecisionGate;
   if (gate !== null && typeof gate === "object" && !Array.isArray(gate)) {
     const record4 = gate;
@@ -5014,7 +5043,7 @@ function humanDecisionText(result2) {
 function projectAuditEscalation(decision, deliveredOutput) {
   const details = buildAuditEscalationResult(decision, deliveredOutput);
   return {
-    content: [{ type: "text", text: humanDecisionText(details) }],
+    content: [{ type: "text", text: humanDecisionText(decision, details) }],
     details,
     terminate: true,
     ...decision.usage === void 0 ? {} : { usage: decision.usage }
@@ -6370,18 +6399,6 @@ init_activation_ledger_topology();
 import { chmod, open, readdir as readdir2, readFile as readFile10, unlink as unlink2, writeFile as writeFile6 } from "node:fs/promises";
 import { join as join15 } from "node:path";
 
-// src/public-cli/invocation.ts
-init_activation_ledger_topology();
-init_activation_ledger_git();
-import {
-  lstat,
-  mkdir as mkdir2,
-  readFile as readFile9,
-  realpath as realpath3,
-  writeFile as writeFile5
-} from "node:fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute3, join as join14, resolve as resolve11, sep as sep3 } from "node:path";
-
 // src/collector-config.ts
 import { createHash as createHash6 } from "node:crypto";
 import { readFile as readFile8 } from "node:fs/promises";
@@ -6456,6 +6473,18 @@ async function loadCollectorManifest(path) {
   return { requests, canonicalJson: canonicalJson2, digest: createHash6("sha256").update(canonicalJson2).digest("hex"), sourcePath: path };
 }
 
+// src/public-cli/invocation.ts
+init_activation_ledger_topology();
+init_activation_ledger_git();
+import {
+  lstat,
+  mkdir as mkdir2,
+  readFile as readFile9,
+  realpath as realpath3,
+  writeFile as writeFile5
+} from "node:fs/promises";
+import { basename as basename4, isAbsolute as isAbsolute3, join as join14, resolve as resolve11, sep as sep3 } from "node:path";
+
 // src/public-cli/option-definitions.ts
 var SHARED_PROJECT_SEMANTICS = {
   id: "project",
@@ -6819,7 +6848,7 @@ var ROLE_COMMAND_HELP = {
   },
   collector: {
     command: "collector",
-    summary: "Collect GitHub PR review evidence (one-shot).",
+    summary: "Collect GitHub PR review evidence.",
     usage: ["ak-role collector --pr <number> [options] [instruction]"],
     examples: [
       "ak-role collector --pr 42 --repo owner/repository",
@@ -6828,7 +6857,7 @@ var ROLE_COMMAND_HELP = {
   },
   doctor: {
     command: "doctor",
-    summary: "Diagnose one retained case (one-shot).",
+    summary: "Diagnose one retained case.",
     usage: ["ak-role doctor --issue <number> [options] [instruction]"],
     examples: [
       'ak-role doctor --issue 115 "Diagnose this retained case."'
@@ -6925,7 +6954,7 @@ var SUPPORT_COMMAND_HELP = {
   },
   resume: {
     command: "resume",
-    summary: "Resume a role run under the live seat table (model/host/engine); session principal must still exist.",
+    summary: "Resume a role run under the live seat table (model/host/engine); session principal must still exist. [message] applies only to seats that accept caller instruction; Notary/\u7B26\u5B9D\u90CE must omit message and derives evidence from the existing source-run/dossier binding.",
     usage: ["ak-role resume <runId> [message]"],
     examples: [
       "ak-role resume 01abc\u2026",
@@ -8379,6 +8408,208 @@ import { Value as Value5 } from "typebox/value";
 // src/submission-ledger.ts
 init_activation_ledger_topology();
 
+// src/gatekeeper-role.ts
+import { Type as Type16 } from "typebox";
+var INSPECTOR_OUTPUT_TOOL = INSPECTOR_OUTPUT_TOOL_NAME;
+var NOTARY_OUTPUT_TOOL = "ak_notary_output";
+var SUBJECT_TOOL = "ak_gatekeeper_subject";
+function gateSeatLabel(stage) {
+  switch (stage) {
+    case "gatekeeper":
+      return "\u95E8\u4E0B\u7701";
+    case "inspector":
+      return "\u5BDF\u9662";
+    case "notary":
+      return "\u7B26\u5B9D\u90CE";
+  }
+}
+var GatekeeperEscalationError = class extends Error {
+  gatekeeper;
+  constructor(gatekeeper) {
+    super(`\u95E8\u4E0B\u7701${gateSeatLabel(gatekeeper.officer)}\u4E0A\u5448`);
+    this.name = "GatekeeperEscalationError";
+    this.gatekeeper = gatekeeper;
+  }
+};
+var officerDecisionSchema = openToolObject(Type16.Object({
+  status: Type16.Unknown({ description: "pass | bounce | escalate \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }),
+  reason: Type16.Optional(Type16.Unknown({ description: "status \u4E3A escalate \u65F6\u7684\u7406\u7531" })),
+  findings: Type16.Unknown({ description: "string[] findings\uFF0C\u968F pass\u3001bounce \u6216 escalate \u7559\u5B58" })
+}));
+var GATEKEEPER_TOOL_SPEC = {
+  name: GATEKEEPER_OUTPUT_TOOL_NAME,
+  label: "\u95E8\u4E0B\u7701\u51B3\u8BAE",
+  description: "\u95E8\u4E0B\u7701\u7EC8\u5C40\u51B3\u8BAE\uFF0C\u72B6\u6001\u4E3A dispatch \u6216 pass\u3002",
+  promptSnippet: "\u95E8\u4E0B\u7701\u51B3\u8BAE",
+  parameters: gatekeeperOutputSchema
+};
+function result(content, details) {
+  return { content: [{ type: "text", text: content }], details };
+}
+function subjectTool(subject) {
+  return {
+    name: SUBJECT_TOOL,
+    description: "\u8BFB\u53D6\u5DF2\u53D7\u7406\u5377\u5B97\uFF1B\u53EA\u4F9B\u53D6\u9605\uFF0C\u4E0D\u8BC4\u5224\u4E0D\u6539\u52A8\u3002",
+    parameters: Type16.Object({}, { additionalProperties: false }),
+    async execute() {
+      return result(JSON.stringify(subject), subject);
+    }
+  };
+}
+function createOfficerDecisionTool(name) {
+  return {
+    name,
+    description: "\u63D0\u4EA4\u4E00\u4EFD typed pass/bounce/escalate \u51B3\u8BAE\u3002",
+    parameters: officerDecisionSchema,
+    async execute(_id, args) {
+      return result(`\u5DF2\u6536 ${String(args?.status)}`, args);
+    }
+  };
+}
+function createGatekeeperOutputTool() {
+  return {
+    name: GATEKEEPER_OUTPUT_TOOL_NAME,
+    description: "\u63D0\u4EA4\u95E8\u4E0B\u7701\u6D3E\u5B98\u51B3\u5B9A\u3002",
+    parameters: gatekeeperDecisionSchema,
+    async execute(_id, args) {
+      return result(`\u5DF2\u6536 ${String(args?.status)}`, args);
+    }
+  };
+}
+async function defaultLoadSoul(role) {
+  return loadGatekeeperSessionMaterials(role);
+}
+function failureReason(error) {
+  if (error instanceof AggregateError) return error.errors.map(failureReason).join("; ");
+  return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+function asStringArray3(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+var MISSING_ARGUMENTS_SUBMISSION = Object.freeze({ missing: "arguments" });
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function retainedSubmission(decision) {
+  return decision === void 0 || isRecord11(decision) && Object.keys(decision).length === 0 ? MISSING_ARGUMENTS_SUBMISSION : decision;
+}
+function noUsableReleaseFailure(stage, decision) {
+  return {
+    status: "transport_failure",
+    stage,
+    reason: stage === "gatekeeper" ? "decision \u65E0\u663E\u5F0F dispatch" : "decision \u65E0\u663E\u5F0F pass/bounce/escalate",
+    submission: retainedSubmission(decision)
+  };
+}
+function readRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return value;
+}
+function projectProvinceDecision(decision) {
+  const projected = projectLawfulGatekeeperOutput(decision);
+  if (projected === void 0) return noUsableReleaseFailure("gatekeeper", decision);
+  if (projected.status === "dispatch") {
+    return { status: "dispatch", officer: projected.officer };
+  }
+  return { status: "pass", findings: projected.findings ?? [] };
+}
+function projectOfficerDecision(officer, decision) {
+  const record4 = readRecord(decision);
+  if (record4 === void 0) return noUsableReleaseFailure(officer, decision);
+  if (record4.status === "bounce") {
+    return {
+      status: "bounce",
+      officer,
+      disposition: "rewrite",
+      findings: asStringArray3(record4.findings),
+      submission: retainedSubmission(decision)
+    };
+  }
+  if (record4.status === "pass") {
+    return {
+      status: "pass",
+      officer,
+      findings: asStringArray3(record4.findings)
+    };
+  }
+  if (record4.status === "escalate") {
+    return {
+      status: "escalate",
+      officer,
+      ...Object.hasOwn(record4, "reason") ? { reason: record4.reason } : {},
+      findings: record4.findings,
+      submission: retainedSubmission(decision)
+    };
+  }
+  return noUsableReleaseFailure(officer, decision);
+}
+async function runGatekeeper(options) {
+  const loadSoul = options.loadSoul ?? defaultLoadSoul;
+  let provinceRun;
+  try {
+    provinceRun = await executeAuditorChild({
+      context: options.context,
+      roleLabel: "Gatekeeper",
+      gateSeat: "gatekeeper",
+      systemPrompt: await loadSoul("gatekeeper"),
+      prompt: "\u5377\u5B97\u5DF2\u53D7\u7406\u3002",
+      tool: createGatekeeperOutputTool(),
+      dossierTool: subjectTool(options.subject),
+      ...options.signal === void 0 ? {} : { signal: options.signal },
+      ...options.runDirectory === void 0 ? {} : { runDirectory: options.runDirectory }
+    });
+  } catch (error) {
+    return { status: "transport_failure", stage: "gatekeeper", reason: failureReason(error) };
+  }
+  if (provinceRun.noReceiptLifecycle !== void 0) {
+    return { status: "no_receipt", stage: "gatekeeper", reason: `${gateSeatLabel("gatekeeper")}\u672A\u4EA7\u751F\u5DF2\u63A5\u53D7\u56DE\u6267\u5373\u6563\u5C40`, facts: provinceRun.noReceiptLifecycle };
+  }
+  const province = projectProvinceDecision(provinceRun.decision);
+  if (province.status !== "dispatch") return province;
+  const officer = province.officer;
+  try {
+    const roleLabel = officer === "inspector" ? "Inspector" : "Notary";
+    const officerRun = await executeAuditorChild({
+      context: options.context,
+      roleLabel,
+      gateSeat: officer,
+      systemPrompt: await loadSoul(officer),
+      prompt: "\u5377\u5B97\u5DF2\u53D7\u7406\u3002",
+      tool: createOfficerDecisionTool(officer === "inspector" ? INSPECTOR_OUTPUT_TOOL : NOTARY_OUTPUT_TOOL),
+      dossierTool: subjectTool(options.subject),
+      ...options.signal === void 0 ? {} : { signal: options.signal },
+      ...options.runDirectory === void 0 ? {} : { runDirectory: options.runDirectory }
+    });
+    if (officerRun.noReceiptLifecycle !== void 0) {
+      return { status: "no_receipt", stage: officer, reason: `${gateSeatLabel(officer)}\u672A\u4EA7\u751F\u5DF2\u63A5\u53D7\u56DE\u6267\u5373\u6563\u5C40`, facts: officerRun.noReceiptLifecycle };
+    }
+    return projectOfficerDecision(officer, officerRun.decision);
+  } catch (error) {
+    return { status: "transport_failure", stage: officer, reason: failureReason(error) };
+  }
+}
+async function requireGatekeeperPass(options) {
+  const gatekeeper = await runGatekeeper({
+    context: options.context,
+    subject: options.subject,
+    ...options.signal === void 0 ? {} : { signal: options.signal }
+  });
+  if (gatekeeper.status === "pass") return;
+  if (gatekeeper.status === "transport_failure") {
+    const error = new Error(`\u95E8\u4E0B\u7701 transport_failure\uFF08${gatekeeper.stage}\uFF09\uFF1A${gatekeeper.reason}`);
+    error.stage = gatekeeper.stage;
+    error.reason = gatekeeper.reason;
+    if (gatekeeper.submission !== void 0) error.submission = gatekeeper.submission;
+    options.hostActions.failInfrastructure(error, options.context, options.toolCallId);
+  }
+  if (gatekeeper.status === "escalate") {
+    throw new GatekeeperEscalationError(gatekeeper);
+  }
+  options.hostActions.bindSubmissionNonPass(options.toolCallId, gatekeeper);
+  throw new GatekeeperDecisionError(gatekeeper);
+}
+
 // src/run-terminal-artifacts.ts
 import { basename as basename6, dirname as dirname13, join as join20 } from "node:path";
 function runIdFromRunDirectory(runDirectory) {
@@ -8399,8 +8630,16 @@ function runIdentity(context) {
   if (typeof headerId === "string" && headerId.length > 0) return headerId;
   throw new Error("\u63D0\u4EA4\u8D26\u9700\u8981\u5DF2\u53D7\u7406\u7684 run \u8EAB\u4EFD");
 }
+function latestUserAttemptId(entries) {
+  const ordered = [...entries];
+  for (let index = ordered.length - 1; index >= 0; index -= 1) {
+    const entry = ordered[index];
+    if (entry?.message?.role === "user" && typeof entry.id === "string") return entry.id;
+  }
+  return void 0;
+}
 function attemptIdentity(context, runId) {
-  return context.sessionManager.getHeader?.()?.id ?? context.sessionManager.getLeafId?.() ?? `${runId}:initial`;
+  return latestUserAttemptId(context.sessionManager.getEntries?.() ?? []) ?? context.sessionManager.getHeader?.()?.id ?? context.sessionManager.getLeafId?.() ?? `${runId}:initial`;
 }
 function submissionRecordFile(cwd, runId, home) {
   const ledgerHome = resolveActivationLedgerHome(home);
@@ -8529,6 +8768,12 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
           const append = (event) => appendFor(state, context, runId, attemptId, event);
           if (state.sealed) throw new Error("\u63D0\u4EA4\u8D26\u5DF2\u5C01\u8D26");
           append({ type: "candidate", attemptId, toolCallId, toolName: tool2.name, sequence: ++state.sequence });
+          const projectOfficerEscalation = (officer, original, deliveredOutput = original) => projectAuditEscalation({
+            ...original,
+            status: "escalate",
+            officer,
+            reason: original.reason === void 0 ? `\u95E8\u4E0B\u7701${officer}\u4E0A\u5448\uFF08\u539F\u5377\u672A\u9644 reason\uFF09` : original.reason
+          }, deliveredOutput);
           let result2;
           try {
             failOnInfrastructureFailureDeclaration(
@@ -8544,7 +8789,14 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
             );
             result2 = await tool2.execute(toolCallId, params, signal, update, context);
           } catch (error) {
-            if (isCorrectableExecuteError(error)) {
+            if (error instanceof GatekeeperEscalationError) {
+              const decision = error.gatekeeper;
+              result2 = projectOfficerEscalation(
+                error.gatekeeper.officer,
+                decision,
+                params
+              );
+            } else if (isCorrectableExecuteError(error)) {
               append({
                 type: "outcome",
                 attemptId,
@@ -8553,6 +8805,7 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
                 code: "typed-bounce",
                 diagnostic: error instanceof Error ? error.message : String(error)
               });
+              throw error;
             } else {
               append({
                 type: "outcome",
@@ -8561,8 +8814,12 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
                 outcome: "infrastructure",
                 diagnostic: error instanceof Error ? error.message : String(error)
               });
+              throw error;
             }
-            throw error;
+          }
+          if ((role === "inspector" || role === "notary") && typeof result2.details === "object" && result2.details !== null && !Array.isArray(result2.details) && result2.details.status === "escalate") {
+            const details = result2.details;
+            result2 = projectOfficerEscalation(role, details);
           }
           if (isAuditEscalationProjection(result2.details)) {
             const candidates2 = rounds.get(attemptId) ?? [];
@@ -8606,463 +8863,62 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
   };
 }
 
-// src/activation-trace.ts
-import { Type as Type16 } from "typebox";
-var causeSchema = Type16.Object({
-  identity: Type16.String({ minLength: 1 }),
-  name: Type16.String({ minLength: 1 }),
-  message: Type16.String(),
-  evidenceId: Type16.Optional(Type16.String({ minLength: 1 }))
-}, { additionalProperties: false });
-var activationTraceRecordSchema = Type16.Object({
-  role: Type16.String({ minLength: 1 }),
-  stageId: Type16.String({ pattern: "^[a-z][a-z0-9-]*$" }),
-  status: Type16.Literal("failed"),
-  timestamp: Type16.String({ format: "date-time" }),
-  cause: causeSchema
-}, { additionalProperties: false });
-var activationCauseEvidence = 0;
-var retainedActivationCauses = /* @__PURE__ */ new Map();
-function namedActivationCause(error) {
-  const evidenceId = `activation-cause-${++activationCauseEvidence}`;
-  retainedActivationCauses.set(evidenceId, error);
-  if (error instanceof Error) {
-    const code = error.code;
-    const name = error.name || "Error";
-    return { identity: typeof code === "string" && code.length > 0 ? code : name, name, message: error.message, evidenceId };
-  }
-  let message;
-  try {
-    message = typeof error === "string" ? error : JSON.stringify(error) ?? String(error);
-    return { identity: "UnknownThrownCause", name: "UnknownThrownCause", message, evidenceId };
-  } catch {
-    return { identity: "UnknownThrownCause", name: "UnknownThrownCause", message: String(error), evidenceId };
-  }
-}
-
-// src/role-runtime.ts
-init_activation_ledger_topology();
+// src/collector-ledger.ts
+import Value3 from "typebox/value";
 
-// src/activation-ledger.ts
-init_activation_ledger_topology();
-init_activation_ledger_git();
-import {
-  constants,
-  closeSync,
-  fstatSync,
-  openSync,
-  writeSync
-} from "node:fs";
-import { dirname as dirname14, isAbsolute as isAbsolute6, resolve as resolve15 } from "node:path";
-
-// src/activation-ledger-session.ts
-init_activation_ledger_topology();
-import {
-  lstatSync as lstatSync2,
-  realpathSync as realpathSync3,
-  statSync as statSync3,
-  writeFileSync as writeFileSync4
-} from "node:fs";
-import { isAbsolute as isAbsolute5, resolve as resolve14 } from "node:path";
-var ActivationSessionFileMissingError = class extends Error {
-  code = "AK_ACTIVATION_SESSION_FILE_MISSING";
-  path;
-  constructor(path, options) {
-    super(
-      `Workflow role activation durable session file does not exist: ${path}`,
-      options?.cause === void 0 ? void 0 : { cause: options.cause }
-    );
-    this.name = "ActivationSessionFileMissingError";
-    this.path = path;
-  }
-};
-function materializeDeferredSessionFile(sessionManager, resolvedFile) {
-  const header = sessionManager.getHeader?.();
-  if (header === null || header === void 0 || header.type !== "session") {
-    throw new ActivationSessionFileMissingError(resolvedFile);
-  }
-  try {
-    writeFileSync4(resolvedFile, `${JSON.stringify(header)}
-`, { flag: "wx" });
-  } catch (error) {
-    if (errnoCode(error) !== "EEXIST") {
-      throw new Error(
-        `Workflow role activation failed to materialize durable session file (${resolvedFile}): ${errorText(error)}`,
-        { cause: error }
-      );
-    }
-  }
-  if (typeof sessionManager.setSessionFile === "function") {
-    sessionManager.setSessionFile(resolvedFile);
-  }
-}
-function durableSessionPointer(sessionManager) {
-  const file = sessionManager.getSessionFile?.();
-  if (typeof file !== "string" || file.length === 0) {
-    throw new Error(
-      "Workflow role activation requires a durable Pi session file principal (getSessionFile); directory-only or --no-session invocations are rejected"
-    );
-  }
-  if (!isAbsolute5(file)) {
-    throw new Error(
-      `Workflow role activation requires an absolute durable session file path; got relative path: ${file}`
-    );
-  }
-  const resolvedFile = resolve14(file);
-  try {
-    lstatSync2(resolvedFile);
-  } catch (error) {
-    if (errnoCode(error) !== "ENOENT") {
-      throw new Error(
-        `Workflow role activation failed to stat durable session file (${resolvedFile}): ${errorText(error)}`,
-        { cause: error }
-      );
-    }
-    try {
-      materializeDeferredSessionFile(sessionManager, resolvedFile);
-    } catch (materializeError) {
-      if (materializeError instanceof ActivationSessionFileMissingError) {
-        throw new ActivationSessionFileMissingError(resolvedFile, { cause: error });
+// src/collector-evidence.ts
+import { createHash as createHash8 } from "node:crypto";
+var COLLECTOR_ELIGIBILITY_MS = 15 * 60 * 1e3;
+function createSystemCollectorClock() {
+  const start = process.hrtime.bigint();
+  return {
+    wallNow: () => /* @__PURE__ */ new Date(),
+    monoNow: () => Number(process.hrtime.bigint() - start) / 1e6,
+    sleep: (ms, signal) => new Promise((resolve17, reject) => {
+      if (signal?.aborted) {
+        reject(signal.reason ?? new Error("aborted"));
+        return;
       }
-      throw materializeError;
-    }
-  }
-  let realFile;
-  try {
-    realFile = realpathSync3(resolvedFile);
-  } catch (error) {
-    throw new ActivationSessionFileMissingError(resolvedFile, { cause: error });
-  }
-  let info;
-  try {
-    info = statSync3(realFile);
-  } catch (error) {
-    throw new Error(
-      `Workflow role activation failed to stat durable session file (${realFile}): ${errorText(error)}`,
-      { cause: error }
-    );
-  }
-  if (info.isDirectory()) {
-    throw new Error(
-      `Workflow role activation durable session principal must be a file, not a directory: ${realFile}`
-    );
-  }
-  if (!info.isFile()) {
-    throw new Error(
-      `Workflow role activation durable session principal is not a regular file: ${realFile}`
-    );
-  }
-  return { kind: "session-file", path: realFile };
+      const timer = setTimeout(resolve17, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal?.reason ?? new Error("aborted"));
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    })
+  };
 }
-
-// src/activation-ledger.ts
-init_activation_ledger_topology();
-var ACTIVATION_LEDGER_APPEND_OPEN_FLAGS = constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_NOFOLLOW;
-var ACCEPTED_ACTIVATION_EVENT = "accepted-activation";
-var ACCEPTED_ACTIVATION_FACT_KEYS = Object.freeze([
-  "event",
-  "role",
-  "observedAt",
-  "bookKey",
-  "session",
-  "correlation"
-]);
-function correlationIdentityFromEnv(env = process.env) {
-  const raw = env.AK_CORRELATION_ID;
-  if (typeof raw === "string" && raw.trim().length > 0) {
-    return { kind: "caller", id: raw };
+function sha256Text(text) {
+  return createHash8("sha256").update(text, "utf8").digest("hex");
+}
+function computeWindowRelation(authoritativeTime, activationTime, deadlineTime) {
+  if (authoritativeTime === void 0 || authoritativeTime === null || authoritativeTime.length === 0) {
+    return "uncertain";
   }
-  return { kind: "absent" };
+  const ms = Date.parse(authoritativeTime);
+  if (!Number.isFinite(ms)) return "uncertain";
+  const activationMs = activationTime.getTime();
+  const deadlineMs = deadlineTime.getTime();
+  if (ms < activationMs) return "before";
+  if (ms <= deadlineMs) return "within";
+  return "after";
 }
-function projectAcceptedActivationFact(input) {
-  const closed = {
-    event: ACCEPTED_ACTIVATION_EVENT,
-    role: input.role,
-    observedAt: input.observedAt,
-    bookKey: input.bookKey,
-    session: { kind: "session-file", path: input.session.path },
-    correlation: input.correlation.kind === "caller" ? { kind: "caller", id: input.correlation.id } : { kind: "absent" }
-  };
-  return Object.fromEntries(
-    ACCEPTED_ACTIVATION_FACT_KEYS.map((key) => [key, closed[key]])
-  );
+function stableId(kind, githubId) {
+  return `${kind}:${githubId}`;
 }
-function buildAcceptedActivationFact(input) {
-  return projectAcceptedActivationFact(input);
+function versionDigest(parts) {
+  return sha256Text(JSON.stringify(parts));
 }
-function serializeAcceptedActivationFact(fact) {
-  return `${JSON.stringify(projectAcceptedActivationFact(fact))}
-`;
+function evidenceIdFor(kind, versionId) {
+  return sha256Text(`${kind}:${versionId}`).slice(0, 16);
 }
-function appendActivationLedgerLine(ledgerPath, line2, options) {
-  if (!isAbsolute6(options.ledgerHome)) {
-    throw new ActivationLedgerError(
-      `activation ledger home must be absolute: ${options.ledgerHome}`
-    );
-  }
-  const resolvedLedger = resolve15(ledgerPath);
-  const resolvedHome = resolve15(options.ledgerHome);
-  const parent = dirname14(resolvedLedger);
-  ensureRealDirectoryTree(resolvedHome, parent);
-  assertLedgerFileInsideHome(resolvedLedger, resolvedHome);
-  if (typeof constants.O_NOFOLLOW !== "number") {
-    throw new ActivationLedgerError(
-      "activation ledger append requires O_NOFOLLOW open-flag support (anti-symlink TOCTOU protection must not be silently dropped); refusing to append"
-    );
-  }
-  const bytes = Buffer.isBuffer(line2) ? line2 : Buffer.from(line2);
-  let ledgerFd;
-  let primaryFailure;
-  try {
-    try {
-      ledgerFd = openSync(resolvedLedger, ACTIVATION_LEDGER_APPEND_OPEN_FLAGS, 420);
-    } catch (error) {
-      throw new ActivationLedgerError(
-        `activation ledger failed to open ledger file (${resolvedLedger}): ${errorText(error)}`,
-        { cause: error }
-      );
-    }
-    let opened;
-    try {
-      opened = fstatSync(ledgerFd);
-    } catch (error) {
-      throw new ActivationLedgerError(
-        `activation ledger failed to fstat ledger file (${resolvedLedger}): ${errorText(error)}`,
-        { cause: error }
-      );
-    }
-    if (!opened.isFile()) {
-      throw new ActivationLedgerError(
-        `activation ledger is not a regular file: ${resolvedLedger}`
-      );
-    }
-    const written = writeSync(ledgerFd, bytes, 0, bytes.length, null);
-    if (written !== bytes.length) {
-      throw new ActivationLedgerError(
-        `activation ledger short write: wrote ${written} of ${bytes.length} bytes to ${resolvedLedger}`
-      );
-    }
-  } catch (error) {
-    primaryFailure = error;
-  }
-  if (ledgerFd !== void 0) {
-    try {
-      closeSync(ledgerFd);
-    } catch (closeFailure) {
-      if (primaryFailure !== void 0) {
-        throw new AggregateError(
-          [primaryFailure, closeFailure],
-          "activation ledger operation and close failed",
-          { cause: primaryFailure }
-        );
-      }
-      throw closeFailure;
-    }
-  }
-  if (primaryFailure !== void 0) throw primaryFailure;
-}
-function appendAcceptedActivationFact(ledgerPath, fact, options) {
-  appendActivationLedgerLine(
-    ledgerPath,
-    Buffer.from(serializeAcceptedActivationFact(fact), "utf8"),
-    { ledgerHome: options.ledgerHome }
-  );
-}
-function appendAcceptedActivationToBook(options) {
-  appendAcceptedActivationFact(
-    activationWaitingLedgerPath(options.ledgerHome, options.fact.bookKey),
-    options.fact,
-    { ledgerHome: options.ledgerHome }
-  );
-}
-
-// src/stderr-jsonl.ts
-import { writeSync as writeSync2 } from "node:fs";
-var STDERR_JSONL_WRITE_RETRY_LIMIT = 100;
-function writeStderrJsonlRecord(record4, write = writeSync2) {
-  const bytes = Buffer.from(`${JSON.stringify(record4)}
-`);
-  let offset = 0;
-  let retries = 0;
-  while (offset < bytes.length) {
-    try {
-      const written = write(2, bytes, offset, bytes.length - offset);
-      if (written <= 0) throw new Error("stderr JSONL write made no progress");
-      offset += written;
-      retries = 0;
-    } catch (error) {
-      const code = error.code;
-      if ((code === "EAGAIN" || code === "EINTR") && retries++ < STDERR_JSONL_WRITE_RETRY_LIMIT) continue;
-      throw error;
-    }
-  }
-}
-
-// src/tool-execution-observation.ts
-import { writeSync as writeSync3 } from "node:fs";
-import { Type as Type17 } from "typebox";
-import { Value as Value3 } from "typebox/value";
-var TOOL_EXECUTION_UPDATE_THROTTLE_MS = 3e4;
-var observationBase = {
-  role: Type17.String({ minLength: 1 }),
-  toolCallId: Type17.String({ minLength: 1 }),
-  toolName: Type17.String({ minLength: 1 }),
-  timestamp: Type17.String({ format: "date-time" })
-};
-var toolExecutionObservationRecordSchema = Type17.Union([
-  Type17.Object({
-    ...observationBase,
-    event: Type17.Literal("tool_execution_start")
-  }, { additionalProperties: true }),
-  Type17.Object({
-    ...observationBase,
-    event: Type17.Literal("tool_execution_update")
-  }, { additionalProperties: true }),
-  Type17.Object({
-    ...observationBase,
-    event: Type17.Literal("tool_execution_end"),
-    isError: Type17.Boolean()
-  }, { additionalProperties: true })
-]);
-function validateToolExecutionObservationRecord(record4) {
-  if (!Value3.Check(toolExecutionObservationRecordSchema, record4)) {
-    throw new TypeError("Tool execution observation record does not match its contract");
-  }
-  return record4;
-}
-function writeToolExecutionObservationRecord(record4, write = writeSync3) {
-  writeStderrJsonlRecord(validateToolExecutionObservationRecord(record4), write);
-}
-function isProducingToolUpdate(partialResult) {
-  if (partialResult == null) return false;
-  if (typeof partialResult !== "object") return true;
-  const content = partialResult.content;
-  if (!Array.isArray(content)) return true;
-  if (content.length === 0) return false;
-  return content.some((part) => {
-    if (typeof part !== "object" || part === null) return true;
-    const text = part.text;
-    if (typeof text === "string") return text.length > 0;
-    return true;
-  });
-}
-function systemToolExecutionObservationMonoNow() {
-  return performance.now();
-}
-function createToolExecutionObservationFace(options) {
-  const states = /* @__PURE__ */ new Map();
-  async function emit(record4) {
-    await options.write(validateToolExecutionObservationRecord(record4));
-  }
-  function activeRole() {
-    if (!options.admitted()) return void 0;
-    const role = options.role();
-    return role === void 0 || role === "" ? void 0 : role;
-  }
-  return {
-    reset() {
-      states.clear();
-    },
-    async onStart(event) {
-      const role = activeRole();
-      if (role === void 0) return;
-      states.set(event.toolCallId, { lastUpdateEmitMonoMs: void 0 });
-      await emit({
-        event: "tool_execution_start",
-        role,
-        toolCallId: event.toolCallId,
-        toolName: event.toolName,
-        timestamp: options.clock()
-      });
-    },
-    async onUpdate(event) {
-      const role = activeRole();
-      if (role === void 0) return;
-      if (!isProducingToolUpdate(event.partialResult)) return;
-      const now = options.monoNow();
-      const state = states.get(event.toolCallId) ?? { lastUpdateEmitMonoMs: void 0 };
-      if (state.lastUpdateEmitMonoMs !== void 0 && now - state.lastUpdateEmitMonoMs < TOOL_EXECUTION_UPDATE_THROTTLE_MS) {
-        return;
-      }
-      state.lastUpdateEmitMonoMs = now;
-      states.set(event.toolCallId, state);
-      await emit({
-        event: "tool_execution_update",
-        role,
-        toolCallId: event.toolCallId,
-        toolName: event.toolName,
-        timestamp: options.clock()
-      });
-    },
-    async onEnd(event) {
-      const role = activeRole();
-      if (role === void 0) return;
-      states.delete(event.toolCallId);
-      await emit({
-        event: "tool_execution_end",
-        role,
-        toolCallId: event.toolCallId,
-        toolName: event.toolName,
-        timestamp: options.clock(),
-        isError: event.isError
-      });
-    }
-  };
-}
-
-// src/collector-evidence.ts
-import { createHash as createHash8 } from "node:crypto";
-var COLLECTOR_ELIGIBILITY_MS = 15 * 60 * 1e3;
-function createSystemCollectorClock() {
-  const start = process.hrtime.bigint();
-  return {
-    wallNow: () => /* @__PURE__ */ new Date(),
-    monoNow: () => Number(process.hrtime.bigint() - start) / 1e6,
-    sleep: (ms, signal) => new Promise((resolve17, reject) => {
-      if (signal?.aborted) {
-        reject(signal.reason ?? new Error("aborted"));
-        return;
-      }
-      const timer = setTimeout(resolve17, ms);
-      const onAbort = () => {
-        clearTimeout(timer);
-        reject(signal?.reason ?? new Error("aborted"));
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-    })
-  };
-}
-function sha256Text(text) {
-  return createHash8("sha256").update(text, "utf8").digest("hex");
-}
-function computeWindowRelation(authoritativeTime, activationTime, deadlineTime) {
-  if (authoritativeTime === void 0 || authoritativeTime === null || authoritativeTime.length === 0) {
-    return "uncertain";
-  }
-  const ms = Date.parse(authoritativeTime);
-  if (!Number.isFinite(ms)) return "uncertain";
-  const activationMs = activationTime.getTime();
-  const deadlineMs = deadlineTime.getTime();
-  if (ms < activationMs) return "before";
-  if (ms <= deadlineMs) return "within";
-  return "after";
-}
-function stableId(kind, githubId) {
-  return `${kind}:${githubId}`;
-}
-function versionDigest(parts) {
-  return sha256Text(JSON.stringify(parts));
-}
-function evidenceIdFor(kind, versionId) {
-  return sha256Text(`${kind}:${versionId}`).slice(0, 16);
-}
-function normalizeAuthenticatedUserEvidence(user, observedAt) {
-  const login = user.login.toLowerCase();
-  const rawId = user.raw?.id;
-  const stableNumericOrStringId = typeof rawId === "number" || typeof rawId === "string" ? rawId : void 0;
-  const retainedRaw = { login };
-  if (stableNumericOrStringId !== void 0) {
-    retainedRaw.id = stableNumericOrStringId;
+function normalizeAuthenticatedUserEvidence(user, observedAt) {
+  const login = user.login.toLowerCase();
+  const rawId = user.raw?.id;
+  const stableNumericOrStringId = typeof rawId === "number" || typeof rawId === "string" ? rawId : void 0;
+  const retainedRaw = { login };
+  if (stableNumericOrStringId !== void 0) {
+    retainedRaw.id = stableNumericOrStringId;
   }
   const contentDigest = versionDigest({
     login,
@@ -9296,28 +9152,25 @@ function assignWindowRelations(records2, activationTime, deadlineTime) {
   }
 }
 
-// src/collector-ledger.ts
-import Value4 from "typebox/value";
-
 // src/collector-tool-schemas.ts
-import { Type as Type18 } from "typebox";
-var collectorObserveArgsSchema = Type18.Object({}, { additionalProperties: false });
-var collectorRequestArgsSchema = Type18.Object({
-  requestId: Type18.String({ minLength: 1, description: "\u914D\u7F6E\u8BF7\u6C42\u8EAB\u4EFD" }),
-  snapshotId: Type18.String({ minLength: 1, description: "\u6700\u65B0\u7559\u5B58\u89C2\u5BDF\u5FEB\u7167" })
+import { Type as Type17 } from "typebox";
+var collectorObserveArgsSchema = Type17.Object({}, { additionalProperties: false });
+var collectorRequestArgsSchema = Type17.Object({
+  requestId: Type17.String({ minLength: 1, description: "\u914D\u7F6E\u8BF7\u6C42\u8EAB\u4EFD" }),
+  snapshotId: Type17.String({ minLength: 1, description: "\u6700\u65B0\u7559\u5B58\u89C2\u5BDF\u5FEB\u7167" })
 }, { additionalProperties: false });
-var collectorReadArgsSchema = Type18.Object({
-  evidenceId: Type18.String({ minLength: 1, description: "observe \u8FD4\u56DE\u7684\u6750\u6599\u8BC1\u636E id\uFF08evidenceId\uFF09" })
+var collectorReadArgsSchema = Type17.Object({
+  evidenceId: Type17.String({ minLength: 1, description: "observe \u8FD4\u56DE\u7684\u6750\u6599\u8BC1\u636E id\uFF08evidenceId\uFF09" })
 }, { additionalProperties: false });
-var collectorWaitArgsSchema = Type18.Object({
-  durationMs: Type18.Integer({ minimum: 1, maximum: COLLECTOR_ELIGIBILITY_MS, description: "\u7B49\u5F85\u6BEB\u79D2\uFF1B\u5355\u6B21\u4E0A\u9650\u4E94\u5206\u949F\u4E14\u4E0D\u8D85\u5269\u4F59\u8D44\u683C" })
+var collectorWaitArgsSchema = Type17.Object({
+  durationMs: Type17.Integer({ minimum: 1, maximum: COLLECTOR_ELIGIBILITY_MS, description: "\u7B49\u5F85\u6BEB\u79D2\uFF1B\u5355\u6B21\u4E0A\u9650\u4E94\u5206\u949F\u4E14\u4E0D\u8D85\u5269\u4F59\u8D44\u683C" })
 }, { additionalProperties: false });
-var collectorFindingArgsSchema = Type18.Object({
-  evidenceId: Type18.String({ minLength: 1, description: "observe \u8FD4\u56DE\u7684\u6750\u6599\u8BC1\u636E id\uFF08evidenceId\uFF09" }),
-  category: Type18.Optional(Type18.String({ minLength: 1, maxLength: 200, description: "\u8BE5 finding \u7684\u7B80\u77ED\u5F52\u7C7B\u6807\u7B7E\uFF1B\u9700\u8981\u5934\u90E8\u4E4B\u5916\u7684\u6B63\u6587\u65F6\u5148\u7528 ak_collector_read \u5F00\u5377\u518D\u5224\u8BFB\uFF0C\u4E0D\u5F97\u8A8A\u5199\u8BC4\u8BBA\u6B63\u6587" }))
+var collectorFindingArgsSchema = Type17.Object({
+  evidenceId: Type17.String({ minLength: 1, description: "observe \u8FD4\u56DE\u7684\u6750\u6599\u8BC1\u636E id\uFF08evidenceId\uFF09" }),
+  category: Type17.Optional(Type17.String({ minLength: 1, maxLength: 200, description: "\u8BE5 finding \u7684\u7B80\u77ED\u5F52\u7C7B\u6807\u7B7E\uFF1B\u9700\u8981\u5934\u90E8\u4E4B\u5916\u7684\u6B63\u6587\u65F6\u5148\u7528 ak_collector_read \u5F00\u5377\u518D\u5224\u8BFB\uFF0C\u4E0D\u5F97\u8A8A\u5199\u8BC4\u8BBA\u6B63\u6587" }))
 }, { additionalProperties: false });
-var collectorOutputBaseSchema = Type18.Object({
-  findings: Type18.Optional(Type18.Array(collectorFindingArgsSchema, {
+var collectorOutputBaseSchema = Type17.Object({
+  findings: Type17.Optional(Type17.Array(collectorFindingArgsSchema, {
     description: "\u672C\u6B21\u6536\u96C6\u5230\u7684\u9010\u6761 findings\uFF1B\u96F6 finding \u7684\u6A21\u677F\u901A\u77E5\u4E0D\u5F97\u8FDB\u5165\u3002\u6B63\u5E38\u5B8C\u5DE5\u65E0 finding \u65F6\u7701\u7565\u3002"
   }))
 }, { additionalProperties: true, description: "\u6B63\u5E38\u5B8C\u5DE5\u63D0\u4EA4\u7A7A\u5BF9\u8C61 {}\uFF1B\u4EC5\u5728\u57FA\u7840\u8BBE\u65BD\u771F\u5B9E\u5931\u8D25\u65F6\u624D\u586B\u5199 infrastructureFailure\uFF0C\u65E0\u5931\u8D25\u65F6\u5FC5\u987B\u7701\u7565\u8BE5\u5B57\u6BB5\u3002" });
@@ -9351,13 +9204,20 @@ function projectObserveContextView(modelView) {
     evidence: modelView.evidence.map((entry) => entry.body === void 0 ? entry : { ...entry, body: utf8SafePrefix(entry.body, COLLECTOR_OBSERVE_BODY_HEAD_BYTES) })
   };
 }
+var COLLECTOR_ACTIVATION_ENTRY_TYPE = "ak-collector-activation";
+var COLLECTOR_SNAPSHOT_ENTRY_TYPE = "ak-collector-snapshot";
+var COLLECTOR_REQUEST_ENTRY_TYPE = "ak-collector-request";
+var COLLECTOR_WAIT_ENTRY_TYPE = "ak-collector-wait";
 function isOperationalTool(name) {
   return COLLECTOR_OPERATIONAL_TOOLS.includes(name);
 }
-function createCollectorLedger(config) {
+function createCollectorLedger(config, options) {
+  const clock = options?.clock;
+  const journal = options?.journal;
   let fatal2 = false;
   let fatalReason;
-  let outputAccepted = false;
+  let outputCandidate = false;
+  let pendingOutputCallId;
   let activationTime;
   let deadlineTime;
   let activationMono;
@@ -9395,14 +9255,14 @@ function createCollectorLedger(config) {
     evidenceById.set(record4.evidenceId, record4);
     return record4;
   };
-  const monoNowOrThrow = (clock) => clock.monoNow();
-  const pastCutoff = (clock) => {
+  const monoNowOrThrow = (clock2) => clock2.monoNow();
+  const pastCutoff = (clock2) => {
     if (deadlineMono === void 0) return false;
-    return monoNowOrThrow(clock) >= deadlineMono;
+    return monoNowOrThrow(clock2) >= deadlineMono;
   };
-  const remainingMs = (clock) => {
+  const remainingMs = (clock2) => {
     if (deadlineMono === void 0) return COLLECTOR_ELIGIBILITY_MS;
-    return Math.max(0, deadlineMono - monoNowOrThrow(clock));
+    return Math.max(0, deadlineMono - monoNowOrThrow(clock2));
   };
   const prIdentity = (pr) => `${pr.state}|${pr.headOid}|${pr.updatedAt ?? ""}`;
   const fetchObserveSurfaces = async (transport, observedAt, signal) => {
@@ -9444,6 +9304,172 @@ function createCollectorLedger(config) {
     });
     return { user, prInitial, reviews, reactions, issueComments, reviewComments, prTerminal };
   };
+  const appendJournal = (customType, data) => {
+    journal?.append(customType, data);
+  };
+  const bindDeadlineMonoFromWall = () => {
+    if (clock === void 0 || activationTime === void 0 || deadlineTime === void 0) return;
+    const wallNow = clock.wallNow().getTime();
+    const monoNow = clock.monoNow();
+    activationMono = monoNow - (wallNow - activationTime.getTime());
+    deadlineMono = monoNow + (deadlineTime.getTime() - wallNow);
+  };
+  const rebindSnapshotCompletedMono = (snapshot) => {
+    const copy = { ...snapshot, evidenceIds: [...snapshot.evidenceIds] };
+    if (deadlineTime !== void 0 && deadlineMono !== void 0 && copy.completedAt !== void 0) {
+      const completedWall = new Date(copy.completedAt).getTime();
+      copy.completedMono = deadlineMono + (completedWall - deadlineTime.getTime());
+    }
+    return copy;
+  };
+  const commitActivationWindow = (nextActivation, nextDeadline) => {
+    if (activationTime !== void 0) return;
+    activationTime = nextActivation;
+    deadlineTime = nextDeadline;
+    bindDeadlineMonoFromWall();
+  };
+  const recoverAmbiguousRequestLosses = (snapshotId, observedRecords) => {
+    for (const failure2 of transportFailures) {
+      if (failure2.recovered || failure2.kind !== "ambiguous_request_loss") continue;
+      if (failure2.marker === void 0 || failure2.requestId === void 0) continue;
+      const found = observedRecords.find(
+        (record4) => record4.kind === "issue_comment" && record4.authorLogin === requesterLogin && typeof record4.body === "string" && record4.body.includes(failure2.marker)
+      );
+      if (found === void 0) continue;
+      failure2.recovered = true;
+      const attempt = attempts.find(
+        (item) => item.status === "ambiguous_loss" && item.requestId === failure2.requestId && item.marker === failure2.marker
+      );
+      if (attempt !== void 0) {
+        attempt.status = "recovered";
+        attempt.commentEvidenceId = found.evidenceId;
+        attempt.recoverySnapshotId = snapshotId;
+      }
+    }
+  };
+  const finalizeObservedSnapshot = (snapshot) => {
+    if (requesterLogin === void 0) {
+      for (const id of snapshot.evidenceIds) {
+        const record4 = evidenceById.get(id);
+        if (record4?.kind === "authenticated_user" && record4.authorLogin !== void 0) {
+          requesterLogin = record4.authorLogin.toLowerCase();
+          break;
+        }
+      }
+    }
+    const stored = rebindSnapshotCompletedMono(snapshot);
+    snapshots.push(stored);
+    latestCompleteSnapshotId = stored.snapshotId;
+    const observedRecords = stored.evidenceIds.flatMap((id) => {
+      const record4 = evidenceById.get(id);
+      return record4 === void 0 ? [] : [record4];
+    });
+    recoverAmbiguousRequestLosses(stored.snapshotId, observedRecords);
+    observedGeneration = mutationGeneration;
+    if (finalObservationRequired && stored.completedMono !== void 0 && deadlineMono !== void 0 && stored.completedMono >= deadlineMono) {
+      finalObservationCompleted = true;
+    } else if (clock !== void 0 && deadlineMono !== void 0 && clock.monoNow() >= deadlineMono && stored.completedMono !== void 0 && stored.completedMono >= deadlineMono) {
+      finalObservationRequired = true;
+      finalObservationCompleted = true;
+    }
+    return stored;
+  };
+  const commitObservedSnapshot = (snapshot, evidenceRecords) => {
+    for (const record4 of evidenceRecords) {
+      storeEvidence(record4);
+    }
+    return finalizeObservedSnapshot(snapshot);
+  };
+  const commitRequestAttempt = (attempt, attemptKey, commentEvidence) => {
+    if (commentEvidence !== void 0) {
+      storeEvidence(commentEvidence);
+    }
+    const existing = attempts.find((item) => item.attemptId === attempt.attemptId);
+    if (existing === void 0) {
+      attempts.push({ ...attempt });
+      attemptKeys.add(attemptKey);
+    } else {
+      Object.assign(existing, attempt);
+    }
+    if (attempt.status === "ambiguous_loss" && !transportFailures.some((failure2) => failure2.requestId === attempt.requestId && failure2.observedHead === attempt.observedHead)) {
+      transportFailures.push({
+        failureId: sha256Text(`loss:${attempt.attemptId}`).slice(0, 16),
+        kind: "ambiguous_request_loss",
+        message: attempt.responseDiagnostics ?? "ambiguous request loss",
+        requestId: attempt.requestId,
+        observedHead: attempt.observedHead,
+        marker: attempt.marker,
+        recovered: false
+      });
+    }
+    if (attempt.status === "succeeded" || attempt.status === "ambiguous_loss") {
+      mutationGeneration += 1;
+      finalObservationCompleted = false;
+    }
+  };
+  const commitWaitRecord = (wait) => {
+    waits.push({ ...wait });
+    if (wait.cutoffReached) finalObservationRequired = true;
+    mutationGeneration += 1;
+    finalObservationCompleted = false;
+  };
+  const replayDossierEntries = (entries) => {
+    const orderedEntries = Array.from(entries);
+    const finalRequestStatus = /* @__PURE__ */ new Map();
+    for (const raw of orderedEntries) {
+      if (typeof raw !== "object" || raw === null) continue;
+      const entry = raw;
+      if (entry.type !== "custom" || entry.customType !== COLLECTOR_REQUEST_ENTRY_TYPE || typeof entry.data !== "object" || entry.data === null) continue;
+      const attempt = entry.data.attempt;
+      if (attempt?.attemptId !== void 0) finalRequestStatus.set(attempt.attemptId, attempt.status);
+    }
+    for (const raw of orderedEntries) {
+      if (typeof raw !== "object" || raw === null) continue;
+      const entry = raw;
+      if (entry.type !== "custom" || typeof entry.data !== "object" || entry.data === null) continue;
+      const data = entry.data;
+      if (entry.customType === COLLECTOR_ACTIVATION_ENTRY_TYPE) {
+        if (typeof data.activationTime === "string" && typeof data.deadlineTime === "string") {
+          commitActivationWindow(new Date(data.activationTime), new Date(data.deadlineTime));
+        }
+        continue;
+      }
+      if (entry.customType === COLLECTOR_SNAPSHOT_ENTRY_TYPE) {
+        const snapshot = data.snapshot;
+        if (snapshot?.snapshotId === void 0 || !Array.isArray(data.evidence)) continue;
+        commitObservedSnapshot(snapshot, data.evidence);
+        continue;
+      }
+      if (entry.customType === COLLECTOR_REQUEST_ENTRY_TYPE) {
+        const attempt = data.attempt;
+        if (attempt?.attemptId === void 0) continue;
+        const attemptKey = typeof data.attemptKey === "string" ? data.attemptKey : [config.repository.canonical, String(config.prNumber), attempt.observedHead, attempt.requestId].join("|");
+        const commentEvidence = data.commentEvidence;
+        const replayAttempt = attempt.status === "started" && finalRequestStatus.get(attempt.attemptId) === "started" ? {
+          ...attempt,
+          status: "ambiguous_loss",
+          responseDiagnostics: "request interrupted after dispatch before completion was recorded"
+        } : attempt;
+        commitRequestAttempt(replayAttempt, attemptKey, commentEvidence);
+        continue;
+      }
+      if (entry.customType === COLLECTOR_WAIT_ENTRY_TYPE) {
+        const wait = data.waitRecord;
+        if (wait?.waitId === void 0) continue;
+        commitWaitRecord(wait);
+      }
+    }
+  };
+  if (options?.dossierEntries !== void 0) {
+    replayDossierEntries(options.dossierEntries);
+  }
+  if (clock !== void 0 && deadlineMono !== void 0 && clock.monoNow() >= deadlineMono) {
+    finalObservationRequired = true;
+    const lastSnap = snapshots.find((item) => item.snapshotId === latestCompleteSnapshotId);
+    if (lastSnap?.completedMono !== void 0 && lastSnap.completedMono >= deadlineMono) {
+      finalObservationCompleted = true;
+    }
+  }
   const ledger = {
     get config() {
       return config;
@@ -9454,8 +9480,8 @@ function createCollectorLedger(config) {
     get fatalReason() {
       return fatalReason;
     },
-    get outputAccepted() {
-      return outputAccepted;
+    get outputCandidate() {
+      return outputCandidate || pendingOutputCallId !== void 0;
     },
     get activationRecorded() {
       return activationTime !== void 0;
@@ -9495,18 +9521,30 @@ function createCollectorLedger(config) {
     },
     latchFatal,
     assertNotFatal,
-    recordActivation(clock) {
+    recordActivation(clock2) {
       assertNotFatal();
       if (activationTime !== void 0) return;
-      activationTime = clock.wallNow();
-      activationMono = clock.monoNow();
+      activationTime = clock2.wallNow();
+      activationMono = clock2.monoNow();
       deadlineTime = new Date(activationTime.getTime() + COLLECTOR_ELIGIBILITY_MS);
       deadlineMono = activationMono + COLLECTOR_ELIGIBILITY_MS;
+      appendJournal(COLLECTOR_ACTIVATION_ENTRY_TYPE, {
+        activationTime: activationTime.toISOString(),
+        deadlineTime: deadlineTime.toISOString()
+      });
+    },
+    recordOutputCandidate() {
+      assertNotFatal();
+      outputCandidate = true;
     },
     beginOperational(toolName, toolCallId) {
       assertNotFatal();
-      if (outputAccepted && toolName !== COLLECTOR_OUTPUT_TOOL) {
-        throw latchFatal("\u56DE\u6267\u5DF2\u53D7\u7406\uFF0C\u672C\u5C40\u4E0D\u518D\u53D7\u7406\u64CD\u4F5C");
+      if (toolName !== COLLECTOR_OUTPUT_TOOL && (outputCandidate || pendingOutputCallId !== void 0)) {
+        throw new Error("\u901A\u8FDB\u53F8\u5DF2\u4EA7\u51FA\u8F93\u51FA\u5019\u9009\uFF0C\u672C\u5C40\u4E0D\u518D\u53D7\u7406\u64CD\u4F5C");
+      }
+      if (toolName === COLLECTOR_OUTPUT_TOOL) {
+        pendingOutputCallId = toolCallId;
+        return;
       }
       if (activeOperationalCallId === toolCallId) {
         return;
@@ -9514,28 +9552,23 @@ function createCollectorLedger(config) {
       if (activeOperationalCallId !== void 0) {
         throw latchFatal("\u901A\u8FDB\u53F8\u64CD\u4F5C\u8C03\u7528\u5DF2\u5728\u8FDB\u884C");
       }
-      if (toolName === COLLECTOR_OUTPUT_TOOL) {
-        return;
-      }
       if (!isOperationalTool(toolName)) {
         throw latchFatal(`\u672A\u77E5\u901A\u8FDB\u53F8\u5DE5\u5177 ${toolName}`);
       }
       activeOperationalCallId = toolCallId;
     },
     completeOperational(toolCallId) {
+      if (pendingOutputCallId === toolCallId) {
+        pendingOutputCallId = void 0;
+      }
       if (activeOperationalCallId === toolCallId) {
         activeOperationalCallId = void 0;
       }
     },
-    markOutputAccepted() {
-      assertNotFatal();
-      if (outputAccepted) throw latchFatal("\u901A\u8FDB\u53F8\u56DE\u6267\u4E3A\u552F\u4E00\u7EC8\u5C40");
-      outputAccepted = true;
-    },
     noteCutoffObserved() {
       finalObservationRequired = true;
     },
-    assertOutputObservationLaw(clock) {
+    assertOutputObservationLaw(clock2) {
       assertNotFatal();
       if (activationTime === void 0 || deadlineTime === void 0 || deadlineMono === void 0) {
         throw new Error("\u901A\u8FDB\u53F8\u56DE\u6267\u9700\u8981\u6FC0\u6D3B\u65F6\u95F4\u7EBF");
@@ -9552,7 +9585,7 @@ function createCollectorLedger(config) {
       if (snapshot === void 0 || !snapshot.complete) {
         throw new Error("\u901A\u8FDB\u53F8\u7EC8\u5C40\u5FEB\u7167\u7F3A\u5931\u6216\u4E0D\u5B8C\u6574");
       }
-      const mono = monoNowOrThrow(clock);
+      const mono = monoNowOrThrow(clock2);
       const atOrAfterCutoff = mono >= deadlineMono;
       if (atOrAfterCutoff) {
         finalObservationRequired = true;
@@ -9564,7 +9597,7 @@ function createCollectorLedger(config) {
         finalObservationCompleted = true;
       }
     },
-    async observe(transport, clock, signal) {
+    async observe(transport, clock2, signal) {
       assertNotFatal();
       if (activationTime === void 0) {
         throw latchFatal("\u901A\u8FDB\u53F8\u89C2\u5BDF\u9700\u8981\u6FC0\u6D3B");
@@ -9573,8 +9606,8 @@ function createCollectorLedger(config) {
         const abortMessage = signal.reason instanceof Error ? signal.reason.message : String(signal.reason ?? "\u5DF2\u4E2D\u6B62");
         throw latchFatal(`\u901A\u8FDB\u53F8\u89C2\u5BDF\u5931\u8D25\uFF1A${abortMessage}`, signal.reason);
       }
-      const observedAt = clock.wallNow().toISOString();
-      const cutoff = pastCutoff(clock);
+      const observedAt = clock2.wallNow().toISOString();
+      const cutoff = pastCutoff(clock2);
       if (cutoff) {
         finalObservationRequired = true;
       }
@@ -9593,8 +9626,8 @@ function createCollectorLedger(config) {
         const message = error instanceof Error ? error.message : "\u672A\u77E5\u5931\u8D25";
         throw latchFatal(`\u901A\u8FDB\u53F8\u89C2\u5BDF\u5931\u8D25\uFF1A${message}`, error);
       }
-      const firstObservedAt = clock.wallNow().toISOString();
-      const firstObservedMono = monoNowOrThrow(clock);
+      const firstObservedAt = clock2.wallNow().toISOString();
+      const firstObservedMono = monoNowOrThrow(clock2);
       const pr = surfaces.prTerminal;
       const { user, reviews, reactions, issueComments, reviewComments } = surfaces;
       requesterLogin = user.login.toLowerCase();
@@ -9638,29 +9671,11 @@ function createCollectorLedger(config) {
         }
         return stored;
       });
-      const completedAt = clock.wallNow().toISOString();
-      const completedMono = clock.monoNow();
+      const completedAt = clock2.wallNow().toISOString();
+      const completedMono = clock2.monoNow();
       const snapshotId = sha256Text(
         `${completedAt}:${pr.headOid}:${storedIds.join(",")}`
       ).slice(0, 16);
-      for (const failure2 of transportFailures) {
-        if (failure2.recovered || failure2.kind !== "ambiguous_request_loss") continue;
-        if (failure2.marker === void 0 || failure2.requestId === void 0) continue;
-        const found = storedRecords.find(
-          (record4) => record4.kind === "issue_comment" && record4.authorLogin === requesterLogin && typeof record4.body === "string" && record4.body.includes(failure2.marker)
-        );
-        if (found) {
-          failure2.recovered = true;
-          const attempt = attempts.find(
-            (item) => item.status === "ambiguous_loss" && item.requestId === failure2.requestId && item.marker === failure2.marker
-          );
-          if (attempt) {
-            attempt.status = "recovered";
-            attempt.commentEvidenceId = found.evidenceId;
-            attempt.recoverySnapshotId = snapshotId;
-          }
-        }
-      }
       const snapshot = {
         snapshotId,
         observedAt,
@@ -9676,28 +9691,38 @@ function createCollectorLedger(config) {
         pageDiagnostics,
         normalizedByteLength
       };
-      snapshots.push(snapshot);
-      latestCompleteSnapshotId = snapshotId;
-      observedGeneration = mutationGeneration;
-      if (finalObservationRequired && completedMono >= (deadlineMono ?? 0)) {
-        finalObservationCompleted = true;
-      } else if (cutoff) {
-        finalObservationCompleted = true;
+      if (cutoff) {
+        finalObservationRequired = true;
       }
+      const committed = finalizeObservedSnapshot(snapshot);
+      appendJournal(COLLECTOR_SNAPSHOT_ENTRY_TYPE, {
+        snapshot: committed,
+        evidence: committed.evidenceIds.flatMap((id) => {
+          const record4 = evidenceById.get(id);
+          return record4 === void 0 ? [] : [record4];
+        })
+      });
       const modelView = buildObserveModelView({
-        snapshot,
-        records: storedRecords,
+        snapshot: committed,
+        records: committed.evidenceIds.flatMap((id) => {
+          const record4 = evidenceById.get(id);
+          return record4 === void 0 ? [] : [record4];
+        }),
         requesterLogin,
         attempts
       });
-      return { snapshot, contextView: projectObserveContextView(modelView) };
+      return {
+        snapshot: committed,
+        modelView,
+        contextView: projectObserveContextView(modelView)
+      };
     },
-    async request(input, transport, clock, signal) {
+    async request(input, transport, clock2, signal) {
       assertNotFatal();
       if (activationTime === void 0 || deadlineTime === void 0) {
         throw latchFatal("\u901A\u8FDB\u53F8\u8BF7\u6C42\u9700\u8981\u6FC0\u6D3B");
       }
-      if (pastCutoff(clock)) {
+      if (pastCutoff(clock2)) {
         finalObservationRequired = true;
         throw latchFatal("\u901A\u8FDB\u53F8\u8BF7\u6C42\u4E0D\u5728\u8D44\u683C\u622A\u6B62\u524D");
       }
@@ -9744,7 +9769,7 @@ function createCollectorLedger(config) {
           `\u901A\u8FDB\u53F8\u8FDB\u7A0B\u5185\u8BF7\u6C42 "${request.id}" \u5728 HEAD ${snapshot.headOid} \u7684 attempt \u5DF2\u7528`
         );
       }
-      const startedAt = clock.wallNow().toISOString();
+      const startedAt = clock2.wallNow().toISOString();
       const attemptId = sha256Text(`${attemptKey}:${startedAt}`).slice(0, 16);
       const attempt = {
         attemptId,
@@ -9756,8 +9781,11 @@ function createCollectorLedger(config) {
         startedAt,
         status: "started"
       };
-      attempts.push(attempt);
-      attemptKeys.add(attemptKey);
+      commitRequestAttempt(attempt, attemptKey, void 0);
+      appendJournal(COLLECTOR_REQUEST_ENTRY_TYPE, {
+        attempt: { ...attempt },
+        attemptKey
+      });
       const result2 = await transport.createIssueComment({
         owner: config.repository.owner,
         repo: config.repository.repo,
@@ -9765,14 +9793,25 @@ function createCollectorLedger(config) {
         body,
         ...signal === void 0 ? {} : { signal }
       });
-      mutationGeneration += 1;
-      finalObservationCompleted = false;
+      const journalRequest = (commentEvidence) => {
+        const attemptKey2 = [
+          config.repository.canonical,
+          String(config.prNumber),
+          attempt.observedHead,
+          attempt.requestId
+        ].join("|");
+        appendJournal(COLLECTOR_REQUEST_ENTRY_TYPE, {
+          attempt: { ...attempt },
+          attemptKey: attemptKey2,
+          commentEvidence
+        });
+      };
       if (result2.kind === "success") {
-        const record4 = storeEvidence(
-          normalizeIssueCommentEvidence(result2.comment, startedAt)
-        );
+        const record4 = normalizeIssueCommentEvidence(result2.comment, startedAt);
         attempt.status = "succeeded";
         attempt.commentEvidenceId = record4.evidenceId;
+        commitRequestAttempt(attempt, attemptKey, record4);
+        journalRequest(record4);
         return {
           status: "succeeded",
           attemptId,
@@ -9785,15 +9824,8 @@ function createCollectorLedger(config) {
       if (result2.kind === "ambiguous_loss") {
         attempt.status = "ambiguous_loss";
         attempt.responseDiagnostics = result2.diagnostics;
-        transportFailures.push({
-          failureId: sha256Text(`loss:${attemptId}`).slice(0, 16),
-          kind: "ambiguous_request_loss",
-          message: result2.diagnostics,
-          requestId: request.id,
-          observedHead: snapshot.headOid,
-          marker,
-          recovered: false
-        });
+        commitRequestAttempt(attempt, attemptKey, void 0);
+        journalRequest(void 0);
         return {
           status: "ambiguous_loss",
           attemptId,
@@ -9805,9 +9837,11 @@ function createCollectorLedger(config) {
       }
       attempt.status = "rejected";
       attempt.responseDiagnostics = result2.diagnostics;
+      commitRequestAttempt(attempt, attemptKey, void 0);
+      journalRequest(void 0);
       throw latchFatal(`\u901A\u8FDB\u53F8\u8BF7\u6C42\u88AB\u62D2\uFF1A${result2.diagnostics}`);
     },
-    async wait(input, clock, signal) {
+    async wait(input, clock2, signal) {
       assertNotFatal();
       if (activationTime === void 0) {
         throw latchFatal("\u901A\u8FDB\u53F8\u7B49\u5F85\u9700\u8981\u6FC0\u6D3B");
@@ -9820,25 +9854,22 @@ function createCollectorLedger(config) {
           `\u901A\u8FDB\u53F8\u7B49\u5F85 durationMs \u81F3\u591A\u4E3A ${COLLECTOR_ELIGIBILITY_MS}`
         );
       }
-      if (pastCutoff(clock)) {
+      if (pastCutoff(clock2)) {
         finalObservationRequired = true;
         throw latchFatal("\u901A\u8FDB\u53F8\u7B49\u5F85\u4E0D\u5728\u8D44\u683C\u622A\u6B62\u524D");
       }
-      const remaining = remainingMs(clock);
+      const remaining = remainingMs(clock2);
       const COLLECTOR_SINGLE_WAIT_MAX_MS = 3e5;
       const effectiveMs = Math.min(
         input.durationMs,
         remaining,
         COLLECTOR_SINGLE_WAIT_MAX_MS
       );
-      const startedAt = clock.wallNow().toISOString();
+      const startedAt = clock2.wallNow().toISOString();
       const waitId = sha256Text(`wait:${startedAt}:${effectiveMs}`).slice(0, 16);
-      await clock.sleep(effectiveMs, signal);
-      const endedAt = clock.wallNow().toISOString();
-      const cutoffReached = pastCutoff(clock);
-      if (cutoffReached) finalObservationRequired = true;
-      mutationGeneration += 1;
-      finalObservationCompleted = false;
+      await clock2.sleep(effectiveMs, signal);
+      const endedAt = clock2.wallNow().toISOString();
+      const cutoffReached = pastCutoff(clock2);
       const record4 = {
         waitId,
         requestedMs: input.durationMs,
@@ -9847,13 +9878,16 @@ function createCollectorLedger(config) {
         endedAt,
         cutoffReached
       };
-      waits.push(record4);
+      commitWaitRecord(record4);
+      appendJournal(COLLECTOR_WAIT_ENTRY_TYPE, {
+        waitRecord: record4
+      });
       return {
         waitId,
         requestedMs: input.durationMs,
         effectiveMs,
         cutoffReached,
-        remainingMsAfter: remainingMs(clock)
+        remainingMsAfter: remainingMs(clock2)
       };
     },
     getSnapshot(snapshotId) {
@@ -9922,6 +9956,410 @@ function buildObserveModelView(input) {
   };
 }
 
+// src/activation-trace.ts
+import { Type as Type18 } from "typebox";
+var causeSchema = Type18.Object({
+  identity: Type18.String({ minLength: 1 }),
+  name: Type18.String({ minLength: 1 }),
+  message: Type18.String(),
+  evidenceId: Type18.Optional(Type18.String({ minLength: 1 }))
+}, { additionalProperties: false });
+var activationTraceRecordSchema = Type18.Object({
+  role: Type18.String({ minLength: 1 }),
+  stageId: Type18.String({ pattern: "^[a-z][a-z0-9-]*$" }),
+  status: Type18.Literal("failed"),
+  timestamp: Type18.String({ format: "date-time" }),
+  cause: causeSchema
+}, { additionalProperties: false });
+var activationCauseEvidence = 0;
+var retainedActivationCauses = /* @__PURE__ */ new Map();
+function namedActivationCause(error) {
+  const evidenceId = `activation-cause-${++activationCauseEvidence}`;
+  retainedActivationCauses.set(evidenceId, error);
+  if (error instanceof Error) {
+    const code = error.code;
+    const name = error.name || "Error";
+    return { identity: typeof code === "string" && code.length > 0 ? code : name, name, message: error.message, evidenceId };
+  }
+  let message;
+  try {
+    message = typeof error === "string" ? error : JSON.stringify(error) ?? String(error);
+    return { identity: "UnknownThrownCause", name: "UnknownThrownCause", message, evidenceId };
+  } catch {
+    return { identity: "UnknownThrownCause", name: "UnknownThrownCause", message: String(error), evidenceId };
+  }
+}
+
+// src/role-runtime.ts
+init_activation_ledger_topology();
+
+// src/activation-ledger.ts
+init_activation_ledger_topology();
+init_activation_ledger_git();
+import {
+  constants,
+  closeSync,
+  fstatSync,
+  openSync,
+  writeSync
+} from "node:fs";
+import { dirname as dirname14, isAbsolute as isAbsolute6, resolve as resolve15 } from "node:path";
+
+// src/activation-ledger-session.ts
+init_activation_ledger_topology();
+import {
+  lstatSync as lstatSync2,
+  realpathSync as realpathSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+import { isAbsolute as isAbsolute5, resolve as resolve14 } from "node:path";
+var ActivationSessionFileMissingError = class extends Error {
+  code = "AK_ACTIVATION_SESSION_FILE_MISSING";
+  path;
+  constructor(path, options) {
+    super(
+      `Workflow role activation durable session file does not exist: ${path}`,
+      options?.cause === void 0 ? void 0 : { cause: options.cause }
+    );
+    this.name = "ActivationSessionFileMissingError";
+    this.path = path;
+  }
+};
+function materializeDeferredSessionFile(sessionManager, resolvedFile) {
+  const header = sessionManager.getHeader?.();
+  if (header === null || header === void 0 || header.type !== "session") {
+    throw new ActivationSessionFileMissingError(resolvedFile);
+  }
+  try {
+    writeFileSync4(resolvedFile, `${JSON.stringify(header)}
+`, { flag: "wx" });
+  } catch (error) {
+    if (errnoCode(error) !== "EEXIST") {
+      throw new Error(
+        `Workflow role activation failed to materialize durable session file (${resolvedFile}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  if (typeof sessionManager.setSessionFile === "function") {
+    sessionManager.setSessionFile(resolvedFile);
+  }
+}
+function durableSessionPointer(sessionManager) {
+  const file = sessionManager.getSessionFile?.();
+  if (typeof file !== "string" || file.length === 0) {
+    throw new Error(
+      "Workflow role activation requires a durable Pi session file principal (getSessionFile); directory-only or --no-session invocations are rejected"
+    );
+  }
+  if (!isAbsolute5(file)) {
+    throw new Error(
+      `Workflow role activation requires an absolute durable session file path; got relative path: ${file}`
+    );
+  }
+  const resolvedFile = resolve14(file);
+  try {
+    lstatSync2(resolvedFile);
+  } catch (error) {
+    if (errnoCode(error) !== "ENOENT") {
+      throw new Error(
+        `Workflow role activation failed to stat durable session file (${resolvedFile}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+    try {
+      materializeDeferredSessionFile(sessionManager, resolvedFile);
+    } catch (materializeError) {
+      if (materializeError instanceof ActivationSessionFileMissingError) {
+        throw new ActivationSessionFileMissingError(resolvedFile, { cause: error });
+      }
+      throw materializeError;
+    }
+  }
+  let realFile;
+  try {
+    realFile = realpathSync3(resolvedFile);
+  } catch (error) {
+    throw new ActivationSessionFileMissingError(resolvedFile, { cause: error });
+  }
+  let info;
+  try {
+    info = statSync3(realFile);
+  } catch (error) {
+    throw new Error(
+      `Workflow role activation failed to stat durable session file (${realFile}): ${errorText(error)}`,
+      { cause: error }
+    );
+  }
+  if (info.isDirectory()) {
+    throw new Error(
+      `Workflow role activation durable session principal must be a file, not a directory: ${realFile}`
+    );
+  }
+  if (!info.isFile()) {
+    throw new Error(
+      `Workflow role activation durable session principal is not a regular file: ${realFile}`
+    );
+  }
+  return { kind: "session-file", path: realFile };
+}
+
+// src/activation-ledger.ts
+init_activation_ledger_topology();
+var ACTIVATION_LEDGER_APPEND_OPEN_FLAGS = constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_NOFOLLOW;
+var ACCEPTED_ACTIVATION_EVENT = "accepted-activation";
+var ACCEPTED_ACTIVATION_FACT_KEYS = Object.freeze([
+  "event",
+  "role",
+  "observedAt",
+  "bookKey",
+  "session",
+  "correlation"
+]);
+function correlationIdentityFromEnv(env = process.env) {
+  const raw = env.AK_CORRELATION_ID;
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    return { kind: "caller", id: raw };
+  }
+  return { kind: "absent" };
+}
+function projectAcceptedActivationFact(input) {
+  const closed = {
+    event: ACCEPTED_ACTIVATION_EVENT,
+    role: input.role,
+    observedAt: input.observedAt,
+    bookKey: input.bookKey,
+    session: { kind: "session-file", path: input.session.path },
+    correlation: input.correlation.kind === "caller" ? { kind: "caller", id: input.correlation.id } : { kind: "absent" }
+  };
+  return Object.fromEntries(
+    ACCEPTED_ACTIVATION_FACT_KEYS.map((key) => [key, closed[key]])
+  );
+}
+function buildAcceptedActivationFact(input) {
+  return projectAcceptedActivationFact(input);
+}
+function serializeAcceptedActivationFact(fact) {
+  return `${JSON.stringify(projectAcceptedActivationFact(fact))}
+`;
+}
+function appendActivationLedgerLine(ledgerPath, line2, options) {
+  if (!isAbsolute6(options.ledgerHome)) {
+    throw new ActivationLedgerError(
+      `activation ledger home must be absolute: ${options.ledgerHome}`
+    );
+  }
+  const resolvedLedger = resolve15(ledgerPath);
+  const resolvedHome = resolve15(options.ledgerHome);
+  const parent = dirname14(resolvedLedger);
+  ensureRealDirectoryTree(resolvedHome, parent);
+  assertLedgerFileInsideHome(resolvedLedger, resolvedHome);
+  if (typeof constants.O_NOFOLLOW !== "number") {
+    throw new ActivationLedgerError(
+      "activation ledger append requires O_NOFOLLOW open-flag support (anti-symlink TOCTOU protection must not be silently dropped); refusing to append"
+    );
+  }
+  const bytes = Buffer.isBuffer(line2) ? line2 : Buffer.from(line2);
+  let ledgerFd;
+  let primaryFailure;
+  try {
+    try {
+      ledgerFd = openSync(resolvedLedger, ACTIVATION_LEDGER_APPEND_OPEN_FLAGS, 420);
+    } catch (error) {
+      throw new ActivationLedgerError(
+        `activation ledger failed to open ledger file (${resolvedLedger}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+    let opened;
+    try {
+      opened = fstatSync(ledgerFd);
+    } catch (error) {
+      throw new ActivationLedgerError(
+        `activation ledger failed to fstat ledger file (${resolvedLedger}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+    if (!opened.isFile()) {
+      throw new ActivationLedgerError(
+        `activation ledger is not a regular file: ${resolvedLedger}`
+      );
+    }
+    const written = writeSync(ledgerFd, bytes, 0, bytes.length, null);
+    if (written !== bytes.length) {
+      throw new ActivationLedgerError(
+        `activation ledger short write: wrote ${written} of ${bytes.length} bytes to ${resolvedLedger}`
+      );
+    }
+  } catch (error) {
+    primaryFailure = error;
+  }
+  if (ledgerFd !== void 0) {
+    try {
+      closeSync(ledgerFd);
+    } catch (closeFailure) {
+      if (primaryFailure !== void 0) {
+        throw new AggregateError(
+          [primaryFailure, closeFailure],
+          "activation ledger operation and close failed",
+          { cause: primaryFailure }
+        );
+      }
+      throw closeFailure;
+    }
+  }
+  if (primaryFailure !== void 0) throw primaryFailure;
+}
+function appendAcceptedActivationFact(ledgerPath, fact, options) {
+  appendActivationLedgerLine(
+    ledgerPath,
+    Buffer.from(serializeAcceptedActivationFact(fact), "utf8"),
+    { ledgerHome: options.ledgerHome }
+  );
+}
+function appendAcceptedActivationToBook(options) {
+  appendAcceptedActivationFact(
+    activationWaitingLedgerPath(options.ledgerHome, options.fact.bookKey),
+    options.fact,
+    { ledgerHome: options.ledgerHome }
+  );
+}
+
+// src/stderr-jsonl.ts
+import { writeSync as writeSync2 } from "node:fs";
+var STDERR_JSONL_WRITE_RETRY_LIMIT = 100;
+function writeStderrJsonlRecord(record4, write = writeSync2) {
+  const bytes = Buffer.from(`${JSON.stringify(record4)}
+`);
+  let offset = 0;
+  let retries = 0;
+  while (offset < bytes.length) {
+    try {
+      const written = write(2, bytes, offset, bytes.length - offset);
+      if (written <= 0) throw new Error("stderr JSONL write made no progress");
+      offset += written;
+      retries = 0;
+    } catch (error) {
+      const code = error.code;
+      if ((code === "EAGAIN" || code === "EINTR") && retries++ < STDERR_JSONL_WRITE_RETRY_LIMIT) continue;
+      throw error;
+    }
+  }
+}
+
+// src/tool-execution-observation.ts
+import { writeSync as writeSync3 } from "node:fs";
+import { Type as Type19 } from "typebox";
+import { Value as Value4 } from "typebox/value";
+var TOOL_EXECUTION_UPDATE_THROTTLE_MS = 3e4;
+var observationBase = {
+  role: Type19.String({ minLength: 1 }),
+  toolCallId: Type19.String({ minLength: 1 }),
+  toolName: Type19.String({ minLength: 1 }),
+  timestamp: Type19.String({ format: "date-time" })
+};
+var toolExecutionObservationRecordSchema = Type19.Union([
+  Type19.Object({
+    ...observationBase,
+    event: Type19.Literal("tool_execution_start")
+  }, { additionalProperties: true }),
+  Type19.Object({
+    ...observationBase,
+    event: Type19.Literal("tool_execution_update")
+  }, { additionalProperties: true }),
+  Type19.Object({
+    ...observationBase,
+    event: Type19.Literal("tool_execution_end"),
+    isError: Type19.Boolean()
+  }, { additionalProperties: true })
+]);
+function validateToolExecutionObservationRecord(record4) {
+  if (!Value4.Check(toolExecutionObservationRecordSchema, record4)) {
+    throw new TypeError("Tool execution observation record does not match its contract");
+  }
+  return record4;
+}
+function writeToolExecutionObservationRecord(record4, write = writeSync3) {
+  writeStderrJsonlRecord(validateToolExecutionObservationRecord(record4), write);
+}
+function isProducingToolUpdate(partialResult) {
+  if (partialResult == null) return false;
+  if (typeof partialResult !== "object") return true;
+  const content = partialResult.content;
+  if (!Array.isArray(content)) return true;
+  if (content.length === 0) return false;
+  return content.some((part) => {
+    if (typeof part !== "object" || part === null) return true;
+    const text = part.text;
+    if (typeof text === "string") return text.length > 0;
+    return true;
+  });
+}
+function systemToolExecutionObservationMonoNow() {
+  return performance.now();
+}
+function createToolExecutionObservationFace(options) {
+  const states = /* @__PURE__ */ new Map();
+  async function emit(record4) {
+    await options.write(validateToolExecutionObservationRecord(record4));
+  }
+  function activeRole() {
+    if (!options.admitted()) return void 0;
+    const role = options.role();
+    return role === void 0 || role === "" ? void 0 : role;
+  }
+  return {
+    reset() {
+      states.clear();
+    },
+    async onStart(event) {
+      const role = activeRole();
+      if (role === void 0) return;
+      states.set(event.toolCallId, { lastUpdateEmitMonoMs: void 0 });
+      await emit({
+        event: "tool_execution_start",
+        role,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        timestamp: options.clock()
+      });
+    },
+    async onUpdate(event) {
+      const role = activeRole();
+      if (role === void 0) return;
+      if (!isProducingToolUpdate(event.partialResult)) return;
+      const now = options.monoNow();
+      const state = states.get(event.toolCallId) ?? { lastUpdateEmitMonoMs: void 0 };
+      if (state.lastUpdateEmitMonoMs !== void 0 && now - state.lastUpdateEmitMonoMs < TOOL_EXECUTION_UPDATE_THROTTLE_MS) {
+        return;
+      }
+      state.lastUpdateEmitMonoMs = now;
+      states.set(event.toolCallId, state);
+      await emit({
+        event: "tool_execution_update",
+        role,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        timestamp: options.clock()
+      });
+    },
+    async onEnd(event) {
+      const role = activeRole();
+      if (role === void 0) return;
+      states.delete(event.toolCallId);
+      await emit({
+        event: "tool_execution_end",
+        role,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        timestamp: options.clock(),
+        isError: event.isError
+      });
+    }
+  };
+}
+
 // src/collector-identity.ts
 function identityKey(identity) {
   if (identity === null) return "unassigned";
@@ -10047,7 +10485,6 @@ function fail4(message) {
 }
 function buildCollectorReceipt(ledger, candidateRaw, clock) {
   ledger.assertNotFatal();
-  if (ledger.outputAccepted) fail4("Collector output is singleton");
   if (ledger.unresolvedTransportFailure) fail4("Collector cannot output while a transport failure is unrecovered");
   if (ledger.latestCompleteSnapshotId === void 0) fail4("Collector output requires a complete final snapshot");
   if (ledger.activationTime === void 0 || ledger.deadlineTime === void 0) fail4("Collector output requires activation timeline");
@@ -10251,10 +10688,13 @@ function createCollectorRoleRuntime(pi, dependencies, hostActions) {
           reason: `\u901A\u8FDB\u53F8\u7981\u7528\u5DE5\u5177 ${event.toolName}`
         };
       }
-      if (activation.ledger.outputAccepted && event.toolName !== COLLECTOR_OUTPUT_TOOL) {
+      if (event.toolName === COLLECTOR_OUTPUT_TOOL) {
+        activation.ledger.beginOperational(COLLECTOR_OUTPUT_TOOL, event.toolCallId);
+      }
+      if (activation.ledger.outputCandidate && event.toolName !== COLLECTOR_OUTPUT_TOOL) {
         return {
           block: true,
-          reason: "\u56DE\u6267\u5DF2\u53D7\u7406\uFF0C\u672C\u5C40\u4E0D\u518D\u53D7\u7406\u64CD\u4F5C"
+          reason: "\u901A\u8FDB\u53F8\u5DF2\u4EA7\u51FA\u8F93\u51FA\u5019\u9009\uFF0C\u672C\u5C40\u4E0D\u518D\u53D7\u7406\u64CD\u4F5C"
         };
       }
       return void 0;
@@ -10265,7 +10705,7 @@ function createCollectorRoleRuntime(pi, dependencies, hostActions) {
     });
     pi.on("session_shutdown", () => {
       if (activation === void 0) return;
-      if (!activation.ledger.outputAccepted || activation.ledger.fatal) {
+      if (activation.ledger.fatal) {
         if (process.exitCode === void 0 || process.exitCode === 0) {
           process.exitCode = 1;
         }
@@ -10433,8 +10873,7 @@ function createCollectorRoleRuntime(pi, dependencies, hostActions) {
             params,
             activation.clock
           );
-          activation.ledger.markOutputAccepted();
-          activation.ledger.completeOperational(toolCallId);
+          activation.ledger.recordOutputCandidate();
           const acceptedDetails = receipt;
           return {
             content: [{
@@ -10449,6 +10888,8 @@ function createCollectorRoleRuntime(pi, dependencies, hostActions) {
             hostActions.failInfrastructure(error, ctx, toolCallId);
           }
           throw error;
+        } finally {
+          activation.ledger.completeOperational(toolCallId);
         }
       }
     });
@@ -10462,7 +10903,7 @@ function createCollectorRoleRuntime(pi, dependencies, hostActions) {
           `Collector supports only print or json mode (got ${ctx.mode})`
         );
       }
-      if (event.reason === "resume" || event.reason === "fork" || event.reason === "reload") {
+      if (event.reason === "fork" || event.reason === "reload") {
         throw new Error(
           `Collector does not support session_start reason ${event.reason}`
         );
@@ -10529,11 +10970,14 @@ function createCollectorRoleRuntime(pi, dependencies, hostActions) {
       }
       const clock = dependencies.createClock?.() ?? createSystemCollectorClock();
       const transport = dependencies.createTransport();
-      const ledger = createCollectorLedger({
-        repository,
-        prNumber,
-        manifest
-      });
+      const ledger = dependencies.createLedger(
+        { repository, prNumber, manifest },
+        clock,
+        ctx
+      );
+      if (ledger.activationRecorded) {
+        firstDispatchDone = true;
+      }
       activation = {
         soul,
         repository,
@@ -10702,7 +11146,7 @@ function createNotaryRoleRuntime(pi, dependencies, host) {
         pi.registerTool({
           name: NOTARY_OUTPUT_TOOL_NAME,
           label: "\u7B26\u5B9D\u90CE\u8F93\u51FA",
-          description: "\u63D0\u4EA4\u5F15\u6587\u4FDD\u771F\u4E0E\u7968\u9762\u5BF9\u9F50\u7684 typed pass/bounce \u51B3\u8BAE\u3002",
+          description: "\u63D0\u4EA4\u5F15\u6587\u4FDD\u771F\u4E0E\u7968\u9762\u5BF9\u9F50\u7684 typed pass/bounce/escalate \u51B3\u8BAE\u3002",
           promptSnippet: "\u63D0\u4EA4\u7B26\u5B9D\u90CE\u51B3\u8BAE",
           parameters: notaryOutputSchema,
           async execute(toolCallId, parameters, _signal, _onUpdate, ctx) {
@@ -10745,24 +11189,24 @@ function createNotaryRoleRuntime(pi, dependencies, host) {
 }
 
 // src/countersign-role.ts
-import { Type as Type19 } from "typebox";
+import { Type as Type20 } from "typebox";
 var countersignVerdictSchema = withInfrastructureFailureDeclaration(
-  Type19.Object(
+  Type20.Object(
     {
       countersignStatus: stringEnum(["converged", "continue", "escalate"], { description: "converged | continue | escalate" }),
-      fix: Type19.Optional(
-        Type19.Object(
-          { summary: Type19.String({ minLength: 1, description: "\u9000\u56DE\u6458\u8981" }) },
+      fix: Type20.Optional(
+        Type20.Object(
+          { summary: Type20.String({ minLength: 1, description: "\u9000\u56DE\u6458\u8981" }) },
           { additionalProperties: false, description: "\u9000\u56DE\u8BF4\u660E" }
         )
       ),
-      note: Type19.Optional(Type19.String({ minLength: 1, description: "\u9644\u6CE8" })),
-      evidence: Type19.Optional(Type19.Unknown({ description: "\u7559\u5B58\u8BC1\u636E" })),
-      decisionGate: Type19.Optional(
-        Type19.Object(
+      note: Type20.Optional(Type20.String({ minLength: 1, description: "\u9644\u6CE8" })),
+      evidence: Type20.Optional(Type20.Unknown({ description: "\u7559\u5B58\u8BC1\u636E" })),
+      decisionGate: Type20.Optional(
+        Type20.Object(
           {
-            question: Type19.String({ minLength: 1 }),
-            options: Type19.Array(Type19.String({ minLength: 1 }), { minItems: 1 })
+            question: Type20.String({ minLength: 1 }),
+            options: Type20.Array(Type20.String({ minLength: 1 }), { minItems: 1 })
           },
           { additionalProperties: false, description: "\u9700\u965B\u4E0B\u5904\u7F6E\u7684\u95EE\u9898\u4E0E\u9009\u9879" }
         )
@@ -10781,18 +11225,18 @@ var COUNTERSIGN_TOOL_SPEC = {
 };
 
 // src/gleaner-left-role.ts
-import { Type as Type20 } from "typebox";
+import { Type as Type21 } from "typebox";
 var gleanerLeftOutputSchema = withInfrastructureFailureDeclaration(
   openToolObject(
-    Type20.Object({
-      status: Type20.Unknown({
+    Type21.Object({
+      status: Type21.Unknown({
         description: "completed \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
       }),
-      findings: Type20.Array(
-        Type20.Object(
+      findings: Type21.Array(
+        Type21.Object(
           {
-            pointer: Type20.String({ description: "\u6587\u4EF6/\u884C\u6307\u9488" }),
-            statement: Type20.String({ description: "\u7591\u70B9\u9648\u8FF0" })
+            pointer: Type21.String({ description: "\u6587\u4EF6/\u884C\u6307\u9488" }),
+            statement: Type21.String({ description: "\u7591\u70B9\u9648\u8FF0" })
           },
           { additionalProperties: true, description: "\u4E00\u6761\u5F39\u7AE0" }
         ),
@@ -10810,208 +11254,30 @@ var GLEANER_LEFT_TOOL_SPEC = {
 };
 
 // src/inspector-role.ts
-import { Type as Type21 } from "typebox";
+import { Type as Type22 } from "typebox";
 var inspectorOutputSchema = withInfrastructureFailureDeclaration(
   openToolObject(
-    Type21.Object({
-      status: Type21.Unknown({
-        description: "pass | bounce \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
+    Type22.Object({
+      status: Type22.Unknown({
+        description: "pass | bounce | escalate \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
       }),
-      findings: Type21.Unknown({
+      findings: Type22.Unknown({
         description: "\u968F\u4EA4\u5377\u7559\u5B58\u7684\u95EE\u9898\u8BB0\u5F55"
-      })
+      }),
+      reason: Type22.Optional(Type22.Unknown({
+        description: "status \u4E3A escalate \u65F6\u7684\u4E0A\u5448\u7406\u7531"
+      }))
     })
   )
 );
 var INSPECTOR_TOOL_SPEC = {
   name: INSPECTOR_OUTPUT_TOOL_NAME,
   label: "\u5BDF\u9662\u8F93\u51FA",
-  description: "\u5BDF\u9662\u7EC8\u5C40\u56DE\u6267\uFF0C\u72B6\u6001\u4E3A pass \u6216 bounce\u3002",
+  description: "\u5BDF\u9662\u7EC8\u5C40\u56DE\u6267\uFF0C\u72B6\u6001\u4E3A pass\u3001bounce \u6216 escalate\u3002",
   promptSnippet: "\u5BDF\u9662\u7EC8\u5C40\u56DE\u6267",
   parameters: inspectorOutputSchema
 };
 
-// src/gatekeeper-role.ts
-import { Type as Type22 } from "typebox";
-var INSPECTOR_OUTPUT_TOOL = INSPECTOR_OUTPUT_TOOL_NAME;
-var NOTARY_OUTPUT_TOOL = "ak_notary_output";
-var SUBJECT_TOOL = "ak_gatekeeper_subject";
-function gateSeatLabel(stage) {
-  switch (stage) {
-    case "gatekeeper":
-      return "\u95E8\u4E0B\u7701";
-    case "inspector":
-      return "\u5BDF\u9662";
-    case "notary":
-      return "\u7B26\u5B9D\u90CE";
-  }
-}
-var officerDecisionSchema = openToolObject(Type22.Object({
-  status: Type22.Unknown({ description: "pass | bounce \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }),
-  findings: Type22.Unknown({ description: "string[] findings\uFF0C\u968F pass \u6216 bounce \u7559\u5B58" })
-}));
-var GATEKEEPER_TOOL_SPEC = {
-  name: GATEKEEPER_OUTPUT_TOOL_NAME,
-  label: "\u95E8\u4E0B\u7701\u51B3\u8BAE",
-  description: "\u95E8\u4E0B\u7701\u7EC8\u5C40\u51B3\u8BAE\uFF0C\u72B6\u6001\u4E3A dispatch \u6216 pass\u3002",
-  promptSnippet: "\u95E8\u4E0B\u7701\u51B3\u8BAE",
-  parameters: gatekeeperOutputSchema
-};
-function result(content, details) {
-  return { content: [{ type: "text", text: content }], details };
-}
-function subjectTool(subject) {
-  return {
-    name: SUBJECT_TOOL,
-    description: "\u8BFB\u53D6\u5DF2\u53D7\u7406\u5377\u5B97\uFF1B\u53EA\u4F9B\u53D6\u9605\uFF0C\u4E0D\u8BC4\u5224\u4E0D\u6539\u52A8\u3002",
-    parameters: Type22.Object({}, { additionalProperties: false }),
-    async execute() {
-      return result(JSON.stringify(subject), subject);
-    }
-  };
-}
-function createOfficerDecisionTool(name) {
-  return {
-    name,
-    description: "\u63D0\u4EA4\u4E00\u4EFD typed pass/bounce \u51B3\u8BAE\u3002",
-    parameters: officerDecisionSchema,
-    async execute(_id, args) {
-      return result(`\u5DF2\u6536 ${String(args?.status)}`, args);
-    }
-  };
-}
-function createGatekeeperOutputTool() {
-  return {
-    name: GATEKEEPER_OUTPUT_TOOL_NAME,
-    description: "\u63D0\u4EA4\u95E8\u4E0B\u7701\u6D3E\u5B98\u51B3\u5B9A\u3002",
-    parameters: gatekeeperDecisionSchema,
-    async execute(_id, args) {
-      return result(`\u5DF2\u6536 ${String(args?.status)}`, args);
-    }
-  };
-}
-async function defaultLoadSoul(role) {
-  return loadGatekeeperSessionMaterials(role);
-}
-function failureReason(error) {
-  if (error instanceof AggregateError) return error.errors.map(failureReason).join("; ");
-  return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-}
-function asStringArray3(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((item) => typeof item === "string");
-}
-var MISSING_ARGUMENTS_SUBMISSION = Object.freeze({ missing: "arguments" });
-function isRecord11(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function retainedSubmission(decision) {
-  return decision === void 0 || isRecord11(decision) && Object.keys(decision).length === 0 ? MISSING_ARGUMENTS_SUBMISSION : decision;
-}
-function noUsableReleaseFailure(stage, decision) {
-  return {
-    status: "transport_failure",
-    stage,
-    reason: stage === "gatekeeper" ? "decision \u65E0\u663E\u5F0F dispatch" : "decision \u65E0\u663E\u5F0F pass/bounce",
-    submission: retainedSubmission(decision)
-  };
-}
-function readRecord(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-  return value;
-}
-function projectProvinceDecision(decision) {
-  const projected = projectLawfulGatekeeperOutput(decision);
-  if (projected === void 0) return noUsableReleaseFailure("gatekeeper", decision);
-  if (projected.status === "dispatch") {
-    return { status: "dispatch", officer: projected.officer };
-  }
-  return { status: "pass", findings: projected.findings ?? [] };
-}
-function projectOfficerDecision(officer, decision) {
-  const record4 = readRecord(decision);
-  if (record4 === void 0) return noUsableReleaseFailure(officer, decision);
-  if (record4.status === "bounce") {
-    return {
-      status: "bounce",
-      officer,
-      disposition: "rewrite",
-      findings: asStringArray3(record4.findings),
-      submission: retainedSubmission(decision)
-    };
-  }
-  if (record4.status === "pass") {
-    return {
-      status: "pass",
-      officer,
-      findings: asStringArray3(record4.findings)
-    };
-  }
-  return noUsableReleaseFailure(officer, decision);
-}
-async function runGatekeeper(options) {
-  const loadSoul = options.loadSoul ?? defaultLoadSoul;
-  let provinceRun;
-  try {
-    provinceRun = await executeAuditorChild({
-      context: options.context,
-      roleLabel: "Gatekeeper",
-      gateSeat: "gatekeeper",
-      systemPrompt: await loadSoul("gatekeeper"),
-      prompt: "\u5377\u5B97\u5DF2\u53D7\u7406\u3002",
-      tool: createGatekeeperOutputTool(),
-      dossierTool: subjectTool(options.subject),
-      ...options.signal === void 0 ? {} : { signal: options.signal },
-      ...options.runDirectory === void 0 ? {} : { runDirectory: options.runDirectory }
-    });
-  } catch (error) {
-    return { status: "transport_failure", stage: "gatekeeper", reason: failureReason(error) };
-  }
-  if (provinceRun.noReceiptLifecycle !== void 0) {
-    return { status: "no_receipt", stage: "gatekeeper", reason: `${gateSeatLabel("gatekeeper")}\u672A\u4EA7\u751F\u5DF2\u63A5\u53D7\u56DE\u6267\u5373\u6563\u5C40`, facts: provinceRun.noReceiptLifecycle };
-  }
-  const province = projectProvinceDecision(provinceRun.decision);
-  if (province.status !== "dispatch") return province;
-  const officer = province.officer;
-  try {
-    const roleLabel = officer === "inspector" ? "Inspector" : "Notary";
-    const officerRun = await executeAuditorChild({
-      context: options.context,
-      roleLabel,
-      gateSeat: officer,
-      systemPrompt: await loadSoul(officer),
-      prompt: "\u5377\u5B97\u5DF2\u53D7\u7406\u3002",
-      tool: createOfficerDecisionTool(officer === "inspector" ? INSPECTOR_OUTPUT_TOOL : NOTARY_OUTPUT_TOOL),
-      dossierTool: subjectTool(options.subject),
-      ...options.signal === void 0 ? {} : { signal: options.signal },
-      ...options.runDirectory === void 0 ? {} : { runDirectory: options.runDirectory }
-    });
-    if (officerRun.noReceiptLifecycle !== void 0) {
-      return { status: "no_receipt", stage: officer, reason: `${gateSeatLabel(officer)}\u672A\u4EA7\u751F\u5DF2\u63A5\u53D7\u56DE\u6267\u5373\u6563\u5C40`, facts: officerRun.noReceiptLifecycle };
-    }
-    return projectOfficerDecision(officer, officerRun.decision);
-  } catch (error) {
-    return { status: "transport_failure", stage: officer, reason: failureReason(error) };
-  }
-}
-async function requireGatekeeperPass(options) {
-  const gatekeeper = await runGatekeeper({
-    context: options.context,
-    subject: options.subject,
-    ...options.signal === void 0 ? {} : { signal: options.signal }
-  });
-  if (gatekeeper.status === "pass") return;
-  if (gatekeeper.status === "transport_failure") {
-    const error = new Error(`\u95E8\u4E0B\u7701 transport_failure\uFF08${gatekeeper.stage}\uFF09\uFF1A${gatekeeper.reason}`);
-    error.stage = gatekeeper.stage;
-    error.reason = gatekeeper.reason;
-    if (gatekeeper.submission !== void 0) error.submission = gatekeeper.submission;
-    options.hostActions.failInfrastructure(error, options.context, options.toolCallId);
-  }
-  options.hostActions.bindSubmissionNonPass(options.toolCallId, gatekeeper);
-  throw new GatekeeperDecisionError(gatekeeper);
-}
-
 // src/navigator-role.ts
 var NAVIGATOR_TOOL_SPEC = {
   name: NAVIGATOR_OUTPUT_TOOL_NAME,
@@ -11027,25 +11293,37 @@ init_upstream_error_testimony();
 
 // src/public-cli/settlement.ts
 var NAVIGATOR_POST_ROLE_GRACE_MS = 1e4;
-function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep = (ms) => new Promise((resolve17) => setTimeout(resolve17, ms))) {
+function defaultNavigatorGraceSleep() {
+  let timer;
+  const sleep = ((ms) => new Promise((resolve17) => {
+    timer = setTimeout(() => {
+      timer = void 0;
+      resolve17();
+    }, ms);
+  }));
+  sleep.cancel = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  return sleep;
+}
+function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep = defaultNavigatorGraceSleep()) {
   return new Promise((resolve17, reject) => {
     let settled = false;
+    const finish = (action) => {
+      if (settled) return;
+      settled = true;
+      sleep.cancel?.();
+      action();
+    };
     void work.then(
-      (value) => {
-        if (settled) return;
-        settled = true;
-        resolve17({ status: "done", value });
-      },
-      (error) => {
-        if (settled) return;
-        settled = true;
-        reject(error);
-      }
+      (value) => finish(() => resolve17({ status: "done", value })),
+      (error) => finish(() => reject(error))
     );
     void sleep(graceMs).then(() => {
-      if (settled) return;
-      settled = true;
-      resolve17({ status: "timeout" });
+      finish(() => resolve17({ status: "timeout" }));
     });
   });
 }
@@ -13148,6 +13426,20 @@ function createRoleRuntimeExtension(dependencies) {
           }
           return dependencies.createCollectorTransport();
         },
+        createLedger(config, collectorClock, context) {
+          const append = context.sessionManager?.appendCustomEntry;
+          return createCollectorLedger(config, {
+            clock: collectorClock,
+            ...append === void 0 ? {} : {
+              journal: {
+                append(customType, data) {
+                  context.sessionManager?.appendCustomEntry?.(customType, data);
+                }
+              }
+            },
+            dossierEntries: context.sessionManager?.getEntries?.() ?? []
+          });
+        },
         ...dependencies.createCollectorClock === void 0 ? {} : { createClock: dependencies.createCollectorClock },
         ...dependencies.collectorPackageExtensionPath === void 0 ? {} : {
           packageExtensionPath: dependencies.collectorPackageExtensionPath
@@ -14115,8 +14407,8 @@ async function prepareGrokRoleEnvelope(options) {
       rejection = value;
     },
     capabilities: {
-      skillExpansion(prompt2) {
-        return buildGrokSkillExpansion(methodSkills, prompt2);
+      skillExpansion(prompt) {
+        return buildGrokSkillExpansion(methodSkills, prompt);
       }
     },
     registerFlag(name, definition) {
@@ -14448,54 +14740,67 @@ async function prepareGrokRoleEnvelope(options) {
     };
     return { accepted: false, failure: failure2 };
   };
-  await emit("session_start", { reason: request.continuation.kind });
-  const inputResults = await emit("input", { text: request.continuation.prompt, source: "interactive" });
-  let prompt = request.continuation.prompt;
-  for (const value of inputResults) {
-    if (typeof value !== "object" || value === null) continue;
-    const record4 = value;
-    if (record4.action === "transform" && typeof record4.text === "string") prompt = record4.text;
-  }
-  if (typeof prompt === "string" && prompt.trim() !== "") {
-    sessionEntries.push({
-      type: "message",
-      message: { role: "user", content: prompt }
+  try {
+    await emit("session_start", { reason: request.continuation.kind });
+    const inputResults = await emit("input", { text: request.continuation.prompt, source: "interactive" });
+    let prompt = request.continuation.prompt;
+    for (const value of inputResults) {
+      if (typeof value !== "object" || value === null) continue;
+      const record4 = value;
+      if (record4.action === "transform" && typeof record4.text === "string") prompt = record4.text;
+    }
+    if (typeof prompt === "string" && prompt.trim() !== "") {
+      sessionEntries.push({
+        type: "message",
+        message: { role: "user", content: prompt }
+      });
+    }
+    const basePrompt = await loadMainRoleSessionMaterials(request.activation.role);
+    const methodPrompt = (await Promise.all(request.methods.map(({ path }) => readFile13(path, "utf8")))).join("\n\n");
+    const promptResults = await emit("before_agent_start", {
+      prompt,
+      systemPrompt: [basePrompt, methodPrompt].filter(Boolean).join("\n\n"),
+      systemPromptOptions: {}
     });
+    const systemPromptBody = [...promptResults].reverse().find((value) => typeof value === "object" && value !== null && "systemPrompt" in value && typeof value.systemPrompt === "string")?.systemPrompt ?? [basePrompt, methodPrompt].filter(Boolean).join("\n\n");
+    const readingMaterials = [];
+    for (const value of promptResults) {
+      if (typeof value !== "object" || value === null) continue;
+      if (!("readingMaterial" in value)) continue;
+      const material = value.readingMaterial;
+      if (material !== void 0) readingMaterials.push(material);
+    }
+    priorAkRoleRunDir = process.env.AK_ROLE_RUN_DIR;
+    process.env.AK_ROLE_RUN_DIR = request.runDirectory;
+    runDirInjected = true;
+    return {
+      mcpServers: [{
+        name: `ak-${request.activation.role}`,
+        command: process.execPath,
+        args: [relay],
+        env: [
+          { name: "AK_GROK_MCP_SOCKET", value: options.socketPath },
+          { name: "AK_GROK_MCP_TOKEN", value: token }
+        ]
+      }],
+      systemPrompt: { body: systemPromptBody, materials: readingMaterials },
+      prompt,
+      abortSignal: hostAbort.signal,
+      closeRound,
+      dispose
+    };
+  } catch (error) {
+    try {
+      await dispose();
+    } catch (cleanupFailure) {
+      throw new AggregateError(
+        [error, cleanupFailure],
+        "prepareGrokRoleEnvelope activation failed and its dispose cleanup also failed",
+        { cause: error }
+      );
+    }
+    throw error;
   }
-  const basePrompt = await loadMainRoleSessionMaterials(request.activation.role);
-  const methodPrompt = (await Promise.all(request.methods.map(({ path }) => readFile13(path, "utf8")))).join("\n\n");
-  const promptResults = await emit("before_agent_start", {
-    prompt,
-    systemPrompt: [basePrompt, methodPrompt].filter(Boolean).join("\n\n"),
-    systemPromptOptions: {}
-  });
-  const systemPromptBody = [...promptResults].reverse().find((value) => typeof value === "object" && value !== null && "systemPrompt" in value && typeof value.systemPrompt === "string")?.systemPrompt ?? [basePrompt, methodPrompt].filter(Boolean).join("\n\n");
-  const readingMaterials = [];
-  for (const value of promptResults) {
-    if (typeof value !== "object" || value === null) continue;
-    if (!("readingMaterial" in value)) continue;
-    const material = value.readingMaterial;
-    if (material !== void 0) readingMaterials.push(material);
-  }
-  priorAkRoleRunDir = process.env.AK_ROLE_RUN_DIR;
-  process.env.AK_ROLE_RUN_DIR = request.runDirectory;
-  runDirInjected = true;
-  return {
-    mcpServers: [{
-      name: `ak-${request.activation.role}`,
-      command: process.execPath,
-      args: [relay],
-      env: [
-        { name: "AK_GROK_MCP_SOCKET", value: options.socketPath },
-        { name: "AK_GROK_MCP_TOKEN", value: token }
-      ]
-    }],
-    systemPrompt: { body: systemPromptBody, materials: readingMaterials },
-    prompt,
-    abortSignal: hostAbort.signal,
-    closeRound,
-    dispose
-  };
 }
 
 // src/grok/session-identity.ts