@akagilnc/pi-workflow-roles 0.1.5382 → 0.1.5462

package/src/public-cli/terminal.ts

@@ -8,6 +8,7 @@
 import type { NoReceiptLifecycleFacts } from "../receipt-delivery-policy.ts";
 import type { ControlledFailureCause } from "../host-contracts.ts";
 import type { PackagedRole } from "../packaged-role-registry.ts";
+import { serializeThrownValue } from "../serialize-thrown-value.ts";
 
 export type { ControlledFailureCause } from "../host-contracts.ts";
 
@@ -25,11 +26,11 @@ export type TerminalArtifactRef = {
 /** Public callable roles that currently produce Terminal outcomes. */
 export type TerminalRoleName = PackagedRole;
 
-export type NoReceiptTerminalOutcome = NoReceiptLifecycleFacts & {
+export type NoReceiptTerminalOutcome = Partial<NoReceiptLifecycleFacts> & {
   kind: "no_receipt";
   role: TerminalRoleName;
   status: "no-accepted-receipt";
-  decisiveFacts: NoReceiptLifecycleFacts & Readonly<Record<string, unknown>>;
+  decisiveFacts: Partial<NoReceiptLifecycleFacts> & Readonly<Record<string, unknown>>;
 };
 
 export type TerminalRoleOutcome =
@@ -56,7 +57,7 @@ export type TerminalRoleOutcome =
       role: TerminalRoleName;
       /**
        * Typed cause class when a typed fact confirms it.
-       * Omitted when unknown — original diagnostic + error artifact carry the fact (#881).
+       * Omitted when unknown — the original diagnostic retains the fact (#881).
        * Never a fabricated "unrecognized" label.
        */
       cause?: ControlledFailureCause;
@@ -102,12 +103,6 @@ export type TerminalNavigatorFact =
       advisoryDiagnostic?: string;
     };
 
-/** Present only when a controlled failure is v1-resumable (typed HTTP 429). */
-export type TerminalResume = {
-  /** Complete public command; run ID is revealed only here. */
-  readonly command: string;
-};
-
 /** Current English gate seat faces projected on Terminal (#478). */
 export type TerminalGateSeat = "gatekeeper" | "inspector" | "notary";
 
@@ -147,38 +142,21 @@ export type TerminalGateFact = {
 };
 
 /**
- * One admitted Role run's typed Terminal aggregate.
- * Resumable failures carry `resume` and must not re-disclose the run ID via
- * top-level `runId` or public artifact path components — only `resume.command`.
- * #416: autoResumeCount (0..2) is a call-local observation of how many in-place
- * auto-resumes occurred during this single LLM call; it is not persisted to
- * run-state.json and does not participate in limit decisions.
- */
-/**
- * Current-result payloads on a terminal — accepted/audit role result, or a
- * rare intentional failure face. Run history is TerminalResult.submissions
- * (#836 / #953), not this helper.
+ * Parent-facing current reply: a court's own accepted/audit payloads only.
+ * Run-scoped history stays on TerminalResult.submissions (#879 / #836), and a
+ * failure face never answers as this court's reply (#953).
  */
-export function roleResultPayloads(outcome: TerminalRoleOutcome): readonly unknown[] {
-  if (outcome.kind === "accepted" || outcome.kind === "audit_escalation") return outcome.payloads ?? [];
-  if (outcome.kind === "failure") return outcome.payloads ?? [];
-  return [];
+export function currentReplyRows(terminal: TerminalResult | undefined): readonly unknown[] {
+  const outcome = terminal?.roleOutcome;
+  return outcome?.kind === "accepted" || outcome?.kind === "audit_escalation"
+    ? outcome.payloads ?? []
+    : [];
 }
 
 /**
- * Prefer non-empty current-result payloads; an empty array must not shadow
- * top-level submissions (#953 / #836). Callers that need failure history must
- * read TerminalResult.submissions directly — do not coalesce into failure.payloads.
+ * One admitted Role run's typed Terminal aggregate.
+ * autoResumeCount is call-local (#416).
  */
-export function coalesceSubmissionRows(
-  payloads: readonly unknown[] | undefined,
-  submissions: readonly unknown[] | undefined,
-): readonly unknown[] {
-  if (payloads !== undefined && payloads.length > 0) return payloads;
-  if (submissions !== undefined && submissions.length > 0) return submissions;
-  return payloads ?? submissions ?? [];
-}
-
 export type TerminalResult = {
   roleOutcome: TerminalRoleOutcome;
   /** Default Reviewer parent: original child Terminals, keyed by frozen axis. */
@@ -207,22 +185,14 @@ export type TerminalResult = {
   /** Call-local auto-resume observation (0..2) for this single LLM call; read-only, not persisted. */
   autoResumeCount?: number;
 } & (
-  | {
-      /** Resumable failure: run ID appears only inside resume.command. */
-      resume: TerminalResume;
-      runId?: undefined;
-      batch?: undefined;
-    }
   | {
       runId: string;
-      resume?: undefined;
       batch?: undefined;
     }
   | {
       /** Deterministic public batch projection; no parent Role run exists. */
       batch: "reviewer";
       runId?: undefined;
-      resume?: undefined;
     }
 );
 
@@ -263,6 +233,19 @@ export function formatTerminalResult(result: TerminalResult): string {
       `diagnostic\t${encodeTerminalField(result.roleOutcome.diagnostic)}`,
     );
   }
+  // Accepted volumes do not dump decisiveFacts unless a failed attempt is
+  // recorded. The unsettled-direction fact still has to be visible on its own.
+  // audit_escalation already dumps every decisiveFact below.
+  if (
+    result.roleOutcome.kind === "accepted"
+    && result.roleOutcome.decisiveFacts?.directionUnsettled === true
+  ) {
+    lines.push("fact\tdirectionUnsettled\ttrue");
+    const subsequent = result.roleOutcome.decisiveFacts.subsequentAudit;
+    if (typeof subsequent === "string") {
+      lines.push(`fact\tsubsequentAudit\t${encodeTerminalField(subsequent)}`);
+    }
+  }
   if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation" || result.roleOutcome.decisiveFacts?.failedAttempts !== undefined) {
     const facts = result.roleOutcome.kind === "accepted"
       ? { failedAttempts: result.roleOutcome.decisiveFacts?.failedAttempts }
@@ -270,7 +253,7 @@ export function formatTerminalResult(result: TerminalResult): string {
     for (const [key, value] of Object.entries(facts)) {
       if (value === undefined) continue;
       const rendered =
-        typeof value === "string" ? value : JSON.stringify(value);
+        typeof value === "string" ? value : serializeThrownValue(value);
       lines.push(`fact\t${encodeTerminalField(key)}\t${encodeTerminalField(rendered)}`);
     }
   }
@@ -315,10 +298,7 @@ export function formatTerminalResult(result: TerminalResult): string {
       }
     }
   }
-  if (result.resume !== undefined) {
-    // Resumable failure: run ID is revealed only inside the complete resume command.
-    lines.push(`resume\t${encodeTerminalField(result.resume.command)}`);
-  } else if (result.runId !== undefined) {
+  if (result.runId !== undefined) {
     lines.push(`run\t${encodeTerminalField(result.runId)}`);
   }
   if (result.autoResumeCount !== undefined) {
@@ -326,27 +306,19 @@ export function formatTerminalResult(result: TerminalResult): string {
   }
   // Role-result block: original payloads, newest first for humans (#961).
   // Typed payloads/submissions stay ledger order; only this presentation reverses.
-  // #953: failure history is the top-level submissions carrier (#836) — present
-  // as recorded-submission, never as this-turn submission/receipt.
-  if (result.roleOutcome.kind === "failure") {
-    const recorded = result.submissions ?? [];
-    for (let i = recorded.length - 1; i >= 0; i -= 1) {
-      const payload = recorded[i]!;
-      const rendered =
-        typeof payload === "string" ? payload : JSON.stringify(payload);
-      lines.push(`recorded-submission\t${encodeTerminalField(rendered)}`);
-    }
-  } else {
-    const payloads =
-      result.roleOutcome.kind === "accepted" ||
-      result.roleOutcome.kind === "audit_escalation"
-        ? coalesceSubmissionRows(result.roleOutcome.payloads, result.submissions)
-        : result.submissions ?? [];
-    for (let i = payloads.length - 1; i >= 0; i -= 1) {
-      const payload = payloads[i]!;
-      const rendered =
-        typeof payload === "string" ? payload : JSON.stringify(payload);
-      lines.push(`submission\t${encodeTerminalField(rendered)}`);
+  // Present the current result and the run history on distinct faces (#879 / #836).
+  // Neither a prior court's submission nor a failed turn's history is this reply.
+  const current = result.roleOutcome.kind === "failure"
+    ? result.roleOutcome.payloads ?? []
+    : currentReplyRows(result);
+  for (const [label, rows] of [
+    ["submission", current],
+    ["recorded-submission", result.submissions ?? []],
+  ] as const) {
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+      const payload = rows[i]!;
+      const rendered = typeof payload === "string" ? payload : JSON.stringify(payload);
+      lines.push(`${label}\t${encodeTerminalField(rendered)}`);
     }
   }
   return `${lines.join("\n")}\n`;

package/src/public-cli/turn-request.ts

@@ -70,7 +70,13 @@ export type RoleTurnRequestProjectionOptions = {
   /** #537 public-invocation scope (one ak-role call). */
   invocationScopeId?: string;
   /** Station child role run (#840): omit automatic navigator attendance. */
-  stationChild?: boolean;
+  readonly stationChild?: boolean;
+  /**
+   * #1132: the one effective delivery-request ceiling (#422 single resolve by
+   * the caller). Projected so the host adapter's own re-ask loop and the AK
+   * execution seam count with the same configured number.
+   */
+  readonly deliveryRequestLimit?: number;
 };
 
 export type AdmittedTurnInvocation = {
@@ -118,6 +124,9 @@ export function projectRoleTurnRequest(
       ? {}
       : { invocationScopeId: options.invocationScopeId }),
     ...(options.stationChild === undefined ? {} : { stationChild: options.stationChild }),
+    ...(options.deliveryRequestLimit === undefined
+      ? {}
+      : { deliveryRequestLimit: options.deliveryRequestLimit }),
   };
 }
 

package/src/public-role-summons.ts

@@ -27,6 +27,7 @@ import type { TerminalResult } from "./public-cli/terminal.ts";
 import type { HostSelectionFailure, NamedRoleTurnHostAdapter } from "./public-cli/role-turn-host-resolution.ts";
 
 import { isRecord, errorText } from "./unknown-value.ts";
+import { serializeThrownValue } from "./serialize-thrown-value.ts";
 
 /** Env published by the parent activation so nested summons never re-derive root. */
 export const AK_ROLE_PACKAGE_ROOT_ENV = "AK_ROLE_PACKAGE_ROOT" as const;
@@ -588,15 +589,9 @@ export async function summonParallelReviewerLenses(options: {
   readonly completeness: PublicSummonResult;
   readonly correctness: PublicSummonResult;
 }> {
-  const describeFailure = (error: unknown): string => {
-    if (error instanceof AggregateError) {
-      return [error.message, ...error.errors.map(describeFailure)].join("\n");
-    }
-    return errorText(error);
-  };
   const failedResult = (error: unknown): PublicSummonResult => ({
     exitCode: 1,
-    stderr: describeFailure(error),
+    stderr: serializeThrownValue(error),
   });
   const dualFailure = (error: unknown) => {
     const failure = failedResult(error);
@@ -720,7 +715,7 @@ export async function summonParallelReviewerLenses(options: {
       ].join("\n");
     }
   } catch (error) {
-    sealDiagnostic = `Reviewer target final seal failed:\n${describeFailure(error)}`;
+    sealDiagnostic = `Reviewer target final seal failed:\n${serializeThrownValue(error)}`;
   }
   if (sealDiagnostic !== undefined) {
     const withSealFailure = (result: PublicSummonResult): PublicSummonResult => ({

package/src/receipt-delivery-policy.ts

@@ -1,14 +1,69 @@
+/**
+ * Shared accepted-receipt delivery budget for role, auditor, and Navigator sessions (#288).
+ *
+ * #1132: the ceiling is the one configured auto-resume value (public-cli.json
+ * top-level `autoResumeLimit`). This module owns no number of its own — the one
+ * package default stays with AUTO_RESUME_LIMIT (#422), and `deliveryTurns`
+ * records the delivery requests actually issued, never the budget
+ * (零次即记零，不把额度或其他续跑次数冒充催交次数).
+ */
+import { AUTO_RESUME_LIMIT } from "./public-cli/run-lifecycle.ts";
+import { parseAutoResumeLimit } from "./public-cli/config.ts";
 import { isRecord } from "./unknown-value.ts";
-/** Shared accepted-receipt delivery budget for role, auditor, and Navigator sessions (#288). */
-export const RECEIPT_DELIVERY_TURN_LIMIT = 2 as const;
 
 export const NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle" as const;
 
+/** One in-process催交 send, tagged with the public call that issued it. */
+export const RECEIPT_DELIVERY_REQUEST_ENTRY = "ak-receipt-delivery-request" as const;
+
+/** A rejection observed by the output-tool hook, bound before any delivery turn. */
+export const RECEIPT_REJECTION_ENTRY = "ak-receipt-rejection" as const;
+
+/**
+ * Facts of one public call. A call with an invocation scope does not share
+ * `current:<runDirectory>` with the previous call on the same run.
+ */
+export function receiptAttemptPointer(runPointer: string, invocationScopeId?: string): string {
+  const scope = invocationScopeId?.trim() ?? "";
+  if (scope.length > 0) return `invocation:${scope}`;
+  return `current:${runPointer}`;
+}
+
+/** Child-process transport for the effective ceiling (#1132). */
+export const RECEIPT_DELIVERY_LIMIT_ENV = "AK_ROLE_RECEIPT_DELIVERY_LIMIT" as const;
+
+/**
+ * The effective receipt-delivery ceiling: the caller's already-resolved
+ * configured value, else the single package default. Domain-validated at this
+ * one seam (#422) so NaN/negative/fractional/Infinity never silently disable
+ * or bypass the comparison downstream.
+ */
+export function deliveryLimitFromConfig(value: number | undefined): number {
+  return parseAutoResumeLimit(value ?? AUTO_RESUME_LIMIT);
+}
+
+/** Effective ceiling for an in-child role runtime reading its own env (#1132). */
+export function deliveryLimitFromEnv(env: NodeJS.ProcessEnv): number {
+  const raw = env[RECEIPT_DELIVERY_LIMIT_ENV];
+  if (raw === undefined || raw.trim() === "") return deliveryLimitFromConfig(undefined);
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed)) return deliveryLimitFromConfig(undefined);
+  return deliveryLimitFromConfig(parsed);
+}
+
+function deliveryTurnsFact(value: unknown): number {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new TypeError("deliveryTurns must be a non-negative integer");
+  }
+  return value;
+}
+
 /** The sole schema shared by lifecycle owners and Terminal projections. */
 export type NoReceiptLifecycleFacts = {
   terminalToolCalled: boolean;
   rejectedReceipts: readonly { reason: string; diagnosticAvailable: boolean }[];
-  deliveryTurns: typeof RECEIPT_DELIVERY_TURN_LIMIT;
+  /** Delivery requests actually issued on this run (#1132 — not a budget). */
+  deliveryTurns: number;
   sessionCompletion: "settled-without-accepted-receipt";
   runPointer: string;
   attemptPointer: string;
@@ -19,7 +74,6 @@ export type NoReceiptLifecycleFacts = {
 export function parseNoReceiptLifecycleFacts(input: unknown): NoReceiptLifecycleFacts {
   if (!isRecord(input)
     || typeof input.terminalToolCalled !== "boolean"
-    || input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT
     || input.sessionCompletion !== "settled-without-accepted-receipt"
     || input.acceptedReceipt !== false
     || typeof input.runPointer !== "string" || input.runPointer.trim() === ""
@@ -29,36 +83,33 @@ export function parseNoReceiptLifecycleFacts(input: unknown): NoReceiptLifecycle
       && typeof item.reason === "string")) {
     throw new TypeError("malformed no-receipt lifecycle facts");
   }
-  return {
+  return noReceiptLifecycleFacts({
     terminalToolCalled: input.terminalToolCalled,
-    rejectedReceipts: input.rejectedReceipts.map((item) => ({
-      reason: item.reason as string,
-      diagnosticAvailable: (item.reason as string).trim() !== "",
-    })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
-    sessionCompletion: "settled-without-accepted-receipt",
+    rejectedReceipts: input.rejectedReceipts as { reason: string }[],
+    deliveryTurns: deliveryTurnsFact(input.deliveryTurns),
     runPointer: input.runPointer,
     attemptPointer: input.attemptPointer,
-    acceptedReceipt: false,
-  };
+  });
 }
 
+/**
+ * #1132: exhaustion is the caller's decision — the receipt-delivery loop only
+ * settles after its budget is actually spent — so this records the issued
+ * count verbatim instead of demanding it equal a package constant.
+ */
 export function noReceiptLifecycleFacts(
   input: Omit<NoReceiptLifecycleFacts, "rejectedReceipts" | "deliveryTurns" | "sessionCompletion" | "acceptedReceipt"> & {
     rejectedReceipts: readonly { reason: string }[];
     deliveryTurns: number;
   },
 ): NoReceiptLifecycleFacts {
-  if (input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT) {
-    throw new TypeError("no-receipt lifecycle requires an exhausted delivery budget");
-  }
   return {
     terminalToolCalled: input.terminalToolCalled,
     rejectedReceipts: input.rejectedReceipts.map(({ reason }) => ({
       reason,
       diagnosticAvailable: reason.trim() !== "",
     })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+    deliveryTurns: deliveryTurnsFact(input.deliveryTurns),
     sessionCompletion: "settled-without-accepted-receipt",
     runPointer: input.runPointer,
     attemptPointer: input.attemptPointer,
@@ -66,39 +117,70 @@ export function noReceiptLifecycleFacts(
   };
 }
 
-export function createReceiptDeliveryPolicy() {
+export function createReceiptDeliveryPolicy(limit?: number) {
+  const deliveryLimit = deliveryLimitFromConfig(limit);
   let accepted = false;
+  let closed = false;
   let terminalToolCalled = false;
+  /** Requests actually sent. Rejections and a nested close do not invent sends. */
   let deliveryTurns = 0;
+  /** Stop counter. Separate from the issued-count fact (#1132). */
+  let budgetSpent = 0;
   const rejectedReceipts: { reason: string; diagnosticAvailable: boolean }[] = [];
+  const spend = (): void => {
+    if (budgetSpent < deliveryLimit) budgetSpent += 1;
+  };
   return {
+    /** The effective ceiling this budget spends (#1132 — never re-read). */
+    limit: deliveryLimit,
     recordAccepted() {
       accepted = true;
       terminalToolCalled = true;
     },
     /** Infrastructure owns terminality and must never trigger receipt催交. */
     stopForInfrastructure() { accepted = true; },
+    /**
+     * Record the rejection this turn already produced.
+     * The fact does not spend a budget. The seam that sends the next prompt
+     * owns that count.
+     */
     recordRejected(reason: string) {
       terminalToolCalled = true;
       rejectedReceipts.push({ reason, diagnosticAvailable: reason.trim() !== "" });
-      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
     },
     recordDeliveryRequest() {
-      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
+      deliveryTurns += 1;
+      spend();
     },
     /**
-     * A nested session settled without an accepted receipt after spending its own
-     * delivery budget. Adopt its facts and close this budget: another prompt would
-     * open an independent session, not a delivery request on the settled one.
+     * Stop asking. The issued count stays whatever was actually sent (#1132 —
+     * do not fill the remainder up to the ceiling).
+     */
+    closeBudget() { closed = true; },
+    /**
+     * A nested session settled without an accepted receipt. Close so this layer
+     * does not open another prompt on that session. The issued count stays the
+     * larger of the two seams: a nested zero must not wipe prompts this layer
+     * already sent, and adding the two counts would bill one send twice.
      */
-    recordNestedNoReceipt(facts: NoReceiptLifecycleFacts) {
-      terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
-      rejectedReceipts.push(...facts.rejectedReceipts);
-      deliveryTurns = RECEIPT_DELIVERY_TURN_LIMIT;
+    recordNestedNoReceipt(facts: Partial<NoReceiptLifecycleFacts>) {
+      if (typeof facts.terminalToolCalled === "boolean") {
+        terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
+      }
+      if (facts.rejectedReceipts !== undefined) {
+        rejectedReceipts.push(...facts.rejectedReceipts);
+      }
+      if (facts.deliveryTurns !== undefined) deliveryTurns = Math.max(deliveryTurns, facts.deliveryTurns);
+      closed = true;
     },
     nextAction(): "accepted" | "request-delivery" | "no-receipt" {
       if (accepted) return "accepted";
-      return deliveryTurns < RECEIPT_DELIVERY_TURN_LIMIT ? "request-delivery" : "no-receipt";
+      if (closed) return "no-receipt";
+      return budgetSpent < deliveryLimit ? "request-delivery" : "no-receipt";
+    },
+    /** Delivery requests actually issued so far (#1132). */
+    issuedDeliveryRequests(): number {
+      return deliveryTurns;
     },
     /** Current typed delivery facts. No prose. */
     deliveryState() {
@@ -112,5 +194,114 @@ export function createReceiptDeliveryPolicy() {
     facts(binding: { runPointer: string; attemptPointer: string }): NoReceiptLifecycleFacts {
       return noReceiptLifecycleFacts({ terminalToolCalled, rejectedReceipts: [...rejectedReceipts], deliveryTurns, ...binding });
     },
+    /**
+     * Continue a public call after the in-memory policy was rebuilt.
+     * Sends already issued spend the same budget; copied rejections keep
+     * the fact and do not spend again.
+     */
+    continueIssued(prior: {
+      readonly deliveryTurns: number;
+      readonly rejectedReceipts: readonly { reason: string }[];
+      readonly terminalToolCalled?: boolean;
+    }) {
+      for (const receipt of prior.rejectedReceipts) {
+        this.recordRejected(receipt.reason);
+      }
+      if (prior.terminalToolCalled === true) terminalToolCalled = true;
+      for (let index = 0; index < prior.deliveryTurns; index += 1) {
+        this.recordDeliveryRequest();
+      }
+    },
+  };
+}
+
+function entryRecord(entry: unknown): Record<string, unknown> | undefined {
+  return isRecord(entry) ? entry : undefined;
+}
+
+/** Sends, observed rejections, and the latest lifecycle fact for this public call. */
+export type ReceiptContinuation = {
+  readonly deliveryTurns: number;
+  readonly rejectedReceipts: readonly { reason: string }[];
+  readonly terminalToolCalled: boolean;
+};
+
+function customTypeOf(record: Record<string, unknown>, message: Record<string, unknown> | undefined): unknown {
+  return record.customType ?? message?.customType;
+}
+
+function dataOf(record: Record<string, unknown>, message: Record<string, unknown> | undefined): unknown {
+  return record.data ?? message?.details;
+}
+
+/** Scope id carried by a delivery request or an invocation-scoped lifecycle fact. */
+function scopeTag(record: Record<string, unknown>): string | undefined {
+  const message = isRecord(record.message) ? record.message : undefined;
+  const customType = customTypeOf(record, message);
+  const data = dataOf(record, message);
+  if (
+    (customType === RECEIPT_DELIVERY_REQUEST_ENTRY || customType === RECEIPT_REJECTION_ENTRY)
+    && isRecord(data)
+    && typeof data.invocationScopeId === "string"
+    && data.invocationScopeId.trim() !== ""
+  ) {
+    return data.invocationScopeId;
+  }
+  if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) return undefined;
+  try {
+    const facts = parseNoReceiptLifecycleFacts(data);
+    const prefix = "invocation:";
+    if (!facts.attemptPointer.startsWith(prefix)) return undefined;
+    const scope = facts.attemptPointer.slice(prefix.length);
+    return scope.trim() === "" ? undefined : scope;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Restore only facts explicitly bound to this public call, never inferred from dialogue. */
+export function priorReceiptContinuation(
+  entries: Iterable<unknown>,
+  invocationScopeId: string,
+): ReceiptContinuation {
+  const pointer = receiptAttemptPointer("", invocationScopeId);
+  let entryTurns = 0;
+  let factTurns = 0;
+  let rejectedReceipts: { reason: string }[] = [];
+  let snapshotTerminal = false;
+  for (const entry of entries) {
+    const record = entryRecord(entry);
+    if (record === undefined) continue;
+    const tagged = scopeTag(record);
+    if (tagged !== undefined) {
+      const message = isRecord(record.message) ? record.message : undefined;
+      const customType = customTypeOf(record, message);
+      if (tagged !== invocationScopeId) continue;
+      if (customType === RECEIPT_DELIVERY_REQUEST_ENTRY) entryTurns += 1;
+      if (customType === RECEIPT_REJECTION_ENTRY) {
+        const data = dataOf(record, message);
+        if (isRecord(data) && typeof data.reason === "string") rejectedReceipts.push({ reason: data.reason });
+      }
+      if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) continue;
+      try {
+        const facts = parseNoReceiptLifecycleFacts(dataOf(record, message));
+        if (facts.attemptPointer !== pointer) continue;
+        factTurns = Math.max(factTurns, facts.deliveryTurns);
+        // Snapshots include all preceding observations. Replay later events,
+        // rather than treating their free-text reasons as deduplication keys.
+        if (facts.rejectedReceipts.length >= rejectedReceipts.length) {
+          rejectedReceipts = facts.rejectedReceipts.map(({ reason }) => ({ reason }));
+        }
+        snapshotTerminal ||= facts.terminalToolCalled;
+      } catch {
+        // A malformed historical entry is not this call's count.
+      }
+      continue;
+    }
+  }
+  return {
+    deliveryTurns: Math.max(entryTurns, factTurns),
+    rejectedReceipts,
+    terminalToolCalled: snapshotTerminal || rejectedReceipts.length > 0,
   };
 }

package/src/role-envelope.ts

@@ -19,6 +19,7 @@ import type {
   RoleTurnRequest,
 } from "./host-contracts.ts";
 import { packagedRoleOutputTool } from "./packaged-role-registry.ts";
+import { deliveryLimitFromConfig } from "./receipt-delivery-policy.ts";
 import {
   createRoleRuntimeExtension,
   type RoleRuntimeDependencies,
@@ -34,6 +35,8 @@ import {
   extractInfrastructureFailureEvidence,
 } from "./navigator-invocation-identity.ts";
 import { serializeThrownValue } from "./serialize-thrown-value.ts";
+import { retainPackageFault } from "./public-cli/settlement.ts";
+import { describeErrorIdentity } from "./public-cli/run-lifecycle.ts";
 
 import { isRecord, errorText } from "./unknown-value.ts";
 
@@ -250,7 +253,10 @@ export async function prepareRoleEnvelope(options: {
     startKeepalive() {},
     stopKeepalive() {},
   };
-  createRoleRuntimeExtension(options.dependencies)(envelope);
+  createRoleRuntimeExtension(
+    options.dependencies,
+    deliveryLimitFromConfig(options.request.deliveryRequestLimit),
+  )(envelope);
 
   const token = randomUUID();
   const server = createServer((socket) => serveSocket(socket));
@@ -553,14 +559,14 @@ export async function prepareRoleEnvelope(options: {
   const dispose = async (): Promise<void> => {
     if (disposed) return;
     disposed = true;
-    const cleanupFailures: unknown[] = [];
+    const requiredFailures: unknown[] = [];
     // session_shutdown may still append package durable entries (navigator
     // attendance when agent_settled was skipped). Drain only after those
     // handlers — single terminal judgment via settleDurableWrites (#959).
     try {
       await emit("session_shutdown", {});
     } catch (error) {
-      cleanupFailures.push(error);
+      requiredFailures.push(error);
     }
     try {
       // Always drain post-shutdown writes. Only throw when the host has not
@@ -568,7 +574,7 @@ export async function prepareRoleEnvelope(options: {
       const alreadyHanded = durableFailureHandedToCloseRound;
       const durableFailure = await settleDurableWrites();
       if (durableFailure !== undefined && !alreadyHanded) {
-        cleanupFailures.push(
+        requiredFailures.push(
           Object.assign(
             new Error(durableFailure.failure.diagnostic ?? "durable session entry flush failed"),
             { code: durableFailure.failure.identity?.code ?? "durable-session-write-failed" },
@@ -576,7 +582,7 @@ export async function prepareRoleEnvelope(options: {
         );
       }
     } catch (error) {
-      cleanupFailures.push(error);
+      requiredFailures.push(error);
     }
     try {
       const closeAll = (server as unknown as { closeAllConnections?: () => void }).closeAllConnections;
@@ -585,12 +591,17 @@ export async function prepareRoleEnvelope(options: {
         server.close((error) => (error ? reject(error) : resolve()));
       });
     } catch (error) {
-      cleanupFailures.push(error);
+      // Closing the relay is ordinary cleanup, not required envelope work.
+      await retainPackageFault({
+        runDirectory: request.runDirectory,
+        diagnostic: `relay close failed beside envelope shutdown: ${describeErrorIdentity(error)}`,
+        error,
+      });
     }
-    if (cleanupFailures.length === 1) throw cleanupFailures[0];
-    if (cleanupFailures.length > 1) {
-      throw new AggregateError(cleanupFailures, "ACP envelope dispose cleanup failures", {
-        cause: cleanupFailures[0],
+    if (requiredFailures.length === 1) throw requiredFailures[0];
+    if (requiredFailures.length > 1) {
+      throw new AggregateError(requiredFailures, "Required envelope shutdown failures", {
+        cause: requiredFailures[0],
       });
     }
   };

package/src/role-runtime-dependencies.ts

@@ -64,6 +64,7 @@ export function createRoleRuntimeDependencies(packageRoot: string): RoleRuntimeD
       authority: options.authority,
       invocationId: options.invocationId,
       createSession: navigatorSessionFactory,
+      ...(options.deliveryRequestLimit === undefined ? {} : { deliveryRequestLimit: options.deliveryRequestLimit }),
       ...(options.contextError === undefined ? {} : { contextError: options.contextError }),
       onEvent: options.onEvent,
     }),