@akagilnc/pi-workflow-roles 0.1.1794 → 0.1.1813

package/src/evidence-child-executor.ts

@@ -32,6 +32,7 @@ import {
 import { wrapPackageOwnedToolDefinition } from "./package-owned-tool-idle.ts";
 import type { ReviewerPromptText } from "./reviewer-prompt-identity.ts";
 import { createStreamIdleGuard, isStreamIdleTimeoutError } from "./stream-idle-guard.ts";
+import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_PROMPT } from "./receipt-delivery-policy.ts";
 
 // ── shared constants / types ──────────────────────────────────────────────
 
@@ -551,6 +552,7 @@ export async function executeAuditorChild(
     let decisionSubmitted = false;
     let decisionCallId: string | undefined;
     let decisionToolFailure: unknown;
+    const decisionToolFailures = new Map<string, unknown>();
     const tool = wrapPackageOwnedToolDefinition({
       ...options.tool,
       label: options.roleLabel,
@@ -562,10 +564,13 @@ export async function executeAuditorChild(
           const result = await options.tool.execute(...args);
           decision = args[1];
           decisionCallId = args[0];
+          decisionToolFailure = undefined;
+          decisionToolFailures.delete(args[0]);
           decisionSubmitted = true;
           return result;
         } catch (error) {
           decisionToolFailure = error;
+          decisionToolFailures.set(args[0], error);
           throw error;
         }
       },
@@ -612,6 +617,8 @@ export async function executeAuditorChild(
     let boundaryResponse: AssistantMessage | undefined;
     let retentionFailure: unknown;
     let retainedResponse: AssistantMessage | undefined;
+    let rejectedDecisionResponse: AssistantMessage | undefined;
+    let promptNeighboringFailure: unknown;
     const registeredToolNames = new Set(session.getAllTools().map((entry) => entry.name));
     const evidenceToolFailures = new Map<string, unknown>();
     for (const name of registeredToolNames) {
@@ -643,21 +650,38 @@ export async function executeAuditorChild(
         turns += 1;
         retainedResponse = event.message;
         try { options.retainResponse?.(event.message); } catch (error) { retentionFailure = error; }
+        // A tool call in assistant output is only an observation. Preserve its
+        // candidate for typed malformed-decision settlement, but the wrapped
+        // execute path above is the sole owner of accepted-receipt state; a
+        // rejected execution must remain retryable in this same session.
         for (const part of event.message.content) {
-          if (part.type !== "toolCall" || part.name !== tool.name) continue;
-          if (!decisionSubmitted) {
-            decision = part.arguments;
-            decisionCallId = part.id;
-            decisionSubmitted = true;
-          } else if (decisionCallId !== part.id) {
-            decisionToolFailure = new Error("Auditor decision was submitted more than once");
+          if (part.type === "toolCall" && part.name === tool.name) {
+            rejectedDecisionResponse = event.message;
+            if (decision === undefined) {
+              decision = part.arguments;
+              decisionCallId = part.id;
+              // Pi can reject malformed root arguments before invoking execute;
+              // that remains the existing typed audit-incomplete candidate path.
+              if (part.arguments === undefined) decisionSubmitted = true;
+            }
           }
         }
         if (turns >= AUDITOR_TURN_LIMIT) boundaryResponse = event.message;
       }
-      if (event.type === "turn_end" &&
-          (decisionSubmitted || boundaryResponse !== undefined || retentionFailure !== undefined)) {
-        void session.abort();
+      if (event.type === "turn_end") {
+        if (rejectedDecisionResponse !== undefined) {
+          promptNeighboringFailure = findToolFailure(rejectedDecisionResponse);
+          const rejectedCall = rejectedDecisionResponse.content.find((part) =>
+            part.type === "toolCall" && part.name === tool.name && decisionToolFailures.has(part.id));
+          if (rejectedCall?.type === "toolCall") {
+            decisionToolFailure = decisionToolFailures.get(rejectedCall.id);
+            decisionToolFailures.delete(rejectedCall.id);
+          }
+        }
+        if (decisionSubmitted || promptNeighboringFailure !== undefined
+          || boundaryResponse !== undefined || retentionFailure !== undefined) {
+          void session.abort();
+        }
       }
     });
     const abort = () => { void session.abort(); };
@@ -666,7 +690,59 @@ export async function executeAuditorChild(
 
     try {
       try {
-        await session.prompt(options.prompt);
+        const delivery = createReceiptDeliveryPolicy();
+        const promptAllowingRejectedDecision = async (prompt: string) => {
+          rejectedDecisionResponse = undefined;
+          promptNeighboringFailure = undefined;
+          decisionToolFailure = undefined;
+          let promptFailure: unknown;
+          try {
+            await session.prompt(prompt);
+          } catch (error) {
+            promptFailure = error;
+          }
+          // Prefer turn_end correlation, but Pi may reject prompt() before that
+          // event. In that case correlate against this prompt's captured decision
+          // response and call-id maps at the catch boundary.
+          const correlatedResponse = rejectedDecisionResponse as AssistantMessage | undefined;
+          if (correlatedResponse !== undefined) {
+            promptNeighboringFailure ??= findToolFailure(correlatedResponse);
+            const rejectedCall = correlatedResponse.content.find((part) =>
+              part.type === "toolCall" && part.name === tool.name && decisionToolFailures.has(part.id));
+            if (rejectedCall?.type === "toolCall") {
+              decisionToolFailure = decisionToolFailures.get(rejectedCall.id);
+              decisionToolFailures.delete(rejectedCall.id);
+            }
+          }
+          // An adjacent failure outranks correctable decision feedback.
+          if (promptNeighboringFailure !== undefined) throw promptNeighboringFailure;
+          if (decisionToolFailure !== undefined) return;
+          if (promptFailure !== undefined) throw promptFailure;
+        };
+        await promptAllowingRejectedDecision(options.prompt);
+        while (!decisionSubmitted && boundaryResponse === undefined && inherited.streamFailure === undefined
+          && delivery.nextAction() === "request-delivery") {
+          if (decisionToolFailure !== undefined) {
+            delivery.recordRejected(decisionToolFailure instanceof Error ? decisionToolFailure.message : String(decisionToolFailure));
+            decisionToolFailure = undefined;
+            if (delivery.nextAction() === "request-delivery") {
+              await promptAllowingRejectedDecision(RECEIPT_DELIVERY_PROMPT);
+            }
+          } else {
+            delivery.recordDeliveryRequest();
+            await promptAllowingRejectedDecision(RECEIPT_DELIVERY_PROMPT);
+          }
+        }
+        if (!decisionSubmitted && boundaryResponse === undefined && inherited.streamFailure === undefined
+          && delivery.nextAction() === "no-receipt") {
+          const runPointer = options.context.sessionManager.getSessionFile() ?? options.context.cwd ?? process.cwd();
+          const attemptPointer = binding.parent.attemptEntryId ?? binding.parent.sessionId ?? `current:${runPointer}`;
+          decision = delivery.facts({ runPointer, attemptPointer });
+          // Late turn_end feedback cannot overturn a lifecycle that has already
+          // charged this prompt to the exhausted shared budget.
+          decisionToolFailure = undefined;
+          auditorSessionManager.appendCustomEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, decision);
+        }
       } catch (error) {
         if (options.signal?.aborted) throw options.signal.reason;
         if (inherited.streamFailure !== undefined) throw inherited.streamFailure;
@@ -761,7 +837,7 @@ export async function executeAuditorChild(
         response === undefined
         || response.stopReason === "error"
         || response.stopReason === "aborted"
-        || !decisionSubmitted
+        || (!decisionSubmitted && decision === undefined)
       ) {
         throw new Error(`${options.roleLabel} exited without a readable decision receipt`);
       }

package/src/judge-role.ts

@@ -135,6 +135,11 @@ export function createJudgeRoleRuntime(
                   terminate: true as const,
                   ...(usage === undefined ? {} : { usage }),
                 }),
+                noReceipt: (auditNoReceipt) => ({
+                  content: [{ type: "text" as const, text: "Judge verdict accepted; compliance audit produced no receipt" }],
+                  details: { ...verdict, auditNoReceipt },
+                  terminate: true as const,
+                }),
                 revise: (violations) => {
                   throw new Error(
                     `Judge verdict violates its soul: ${violations.join("; ")}`,

package/src/navigator-attendance.ts

@@ -19,6 +19,7 @@ import { openInProcessAgentSession } from "./in-process-session.ts";
 import { renderPublicAkRoleCommand } from "./public-command-renderer.ts";
 import { issueRoot, subjectPath } from "./work-subject-identity.ts";
 import { wrapPackageOwnedToolDefinition } from "./package-owned-tool-idle.ts";
+import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_PROMPT } from "./receipt-delivery-policy.ts";
 
 export const NAVIGATOR_EVENT_TYPE = "ak-navigator-attendance" as const;
 export const NAVIGATOR_PREPARE_TOOL_NAME = "ak_navigator_prepare" as const;
@@ -278,6 +279,36 @@ function unavailableKey(value: unknown): NavigatorUnavailableKey | undefined {
 function exactRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+
+/** Correlate one rejected prepare call/result inside the just-finished prompt. */
+function rejectedPrepareReason(entries: readonly unknown[], start: number): string | undefined {
+  const recent = entries.slice(start);
+  const prepareCalls = new Set<string>();
+  for (const entry of recent) {
+    if (!exactRecord(entry) || entry.type !== "message" || !exactRecord(entry.message)
+      || entry.message.role !== "assistant" || !Array.isArray(entry.message.content)) continue;
+    for (const part of entry.message.content) {
+      if (exactRecord(part) && part.type === "toolCall" && part.name === NAVIGATOR_PREPARE_TOOL_NAME
+        && typeof part.id === "string") prepareCalls.add(part.id);
+    }
+  }
+  let reason: string | undefined;
+  for (const entry of recent) {
+    if (!exactRecord(entry) || entry.type !== "message" || !exactRecord(entry.message)
+      || entry.message.role !== "toolResult" || entry.message.isError !== true) continue;
+    const callId = entry.message.toolCallId;
+    if (entry.message.toolName !== NAVIGATOR_PREPARE_TOOL_NAME
+      || typeof callId !== "string" || !prepareCalls.has(callId)) {
+      return undefined;
+    }
+    const content = entry.message.content;
+    const text = Array.isArray(content)
+      ? content.flatMap((part) => exactRecord(part) && typeof part.text === "string" ? [part.text] : []).join("")
+      : typeof content === "string" ? content : "";
+    if (text.trim() !== "") reason = text.trim();
+  }
+  return reason;
+}
 function targetIsValid(value: unknown): value is NavigatorRouteTarget {
   if (!exactRecord(value) || !targetRoles.has(String(value.role))) return false;
   const metadata = packagedRoleMetadata(String(value.role));
@@ -567,6 +598,7 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
   let settlementTail: Promise<void> = Promise.resolve();
   let settlementFailure: unknown;
   let preparationFailure: unknown;
+  let preparationNoReceipt = false;
   let routePlaybookReadFailure: string | undefined;
   let disposed = false;
   /** One-shot live-help warm; consumed by the next prepare so later prepares reread live help. */
@@ -770,7 +802,38 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
       try {
         try {
           if (disposed) throw navigatorUnavailableError("session", new Error("Navigator attendance was disposed"));
-          await activeSession.prompt(request);
+          const delivery = createReceiptDeliveryPolicy();
+          const promptAllowingRejectedPrepare = async (text: string, deliveryRequest: boolean) => {
+            const entryStart = activeSession.entries().length;
+            let promptFailure: unknown;
+            try {
+              await activeSession.prompt(text);
+            } catch (error) {
+              promptFailure = error;
+            }
+            const providerFailure = activeSession.providerFailure?.();
+            if (providerFailure !== undefined) {
+              throw navigatorUnavailableError(providerFailure.source, promptFailure ?? "Navigator provider failure", providerFailure.cause);
+            }
+            const rejectedReason = rejectedPrepareReason(activeSession.entries(), entryStart);
+            if (rejectedReason !== undefined) {
+              delivery.recordRejected(rejectedReason);
+              return;
+            }
+            if (promptFailure !== undefined) throw promptFailure;
+            if (deliveryRequest && output === undefined) delivery.recordDeliveryRequest();
+          };
+          await promptAllowingRejectedPrepare(request, false);
+          while (output === undefined && delivery.nextAction() === "request-delivery") {
+            await promptAllowingRejectedPrepare(RECEIPT_DELIVERY_PROMPT, true);
+          }
+          if (output === undefined && delivery.nextAction() === "no-receipt" && activeSession.providerFailure?.() === undefined) {
+            const facts = delivery.facts({ runPointer: sessionDir, attemptPointer: invocationId });
+            activeSession.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
+            preparationNoReceipt = true;
+            candidates = [];
+            return candidates;
+          }
         } catch (error) {
           throw error instanceof NavigatorUnavailableError ? error : navigatorUnavailableError("transport", error);
         }
@@ -907,10 +970,13 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
               throw new Error("Navigator advice contradicts the accepted settlement");
             }
           }
-          // Usable model/authority next only — never invent from settlement role/status, prior absence, or prose.
-          if (selected?.next === undefined) {
+          // Budget exhaustion is affirmative typed no-advice; malformed submitted
+          // advice remains the existing unavailable path.
+          if (selected?.next === undefined && preparationNoReceipt) {
+            report = { disposition: "no-advice" };
+          } else if (selected?.next === undefined) {
             throw new Error("Navigator prepared no machine-usable next direction");
-          }
+          } else {
           const selectedRoute = selected.route;
           const routeChanged = selectedRoute !== undefined && !routeEqual(previousRoute, selectedRoute);
           // Single owner: public registry renderer (ADR 0052). Model command prose is never authority.
@@ -926,6 +992,7 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
             previousRoute = selectedRoute;
             session?.appendEntry(ROUTE_ENTRY, { invocationId, subjectKey, route: selectedRoute });
           }
+          }
         // Contract: README.md#Navigator-attendance — Navigator failures become typed unavailable without invalidating the role Receipt; retain the original cause in the unavailable report.
         } catch (error) {
           report = unavailable(invocationId, error);
@@ -964,6 +1031,7 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
       sessionReady = undefined;
       candidates = undefined;
       preparationFailure = undefined;
+      preparationNoReceipt = false;
       routePlaybookSettlement = undefined;
       routePlaybookReadFailure = undefined;
   }

package/src/public-cli/settlement.ts

@@ -74,6 +74,7 @@ import {
   type InvocationMarkerIdentity,
 } from "../navigator-invocation-identity.ts";
 import type { NavigatorPhase } from "../navigator-attendance.ts";
+import { NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, parseNoReceiptLifecycleFacts, type NoReceiptLifecycleFacts } from "../receipt-delivery-policy.ts";
 import { packagedRoleMetadata } from "../packaged-role-registry.ts";
 import {
   workSubjectKeyFromProjectRoot,
@@ -856,11 +857,21 @@ function safelyRead(object: object, key: string): { readable: true; value: unkno
   }
 }
 
+function auditNoReceiptDecisiveFact(candidate: object): Record<string, unknown> {
+  const projected = safelyRead(candidate, "auditNoReceipt");
+  if (!projected.readable || projected.value === undefined) return {};
+  try {
+    return { auditNoReceipt: parseNoReceiptLifecycleFacts(projected.value) };
+  } catch {
+    return {};
+  }
+}
+
 function judgeDecisiveFacts(
   verdict: object,
   judgeStatus: JudgeVerdict["judgeStatus"],
 ): Record<string, unknown> {
-  const facts: Record<string, unknown> = { judgeStatus };
+  const facts: Record<string, unknown> = { judgeStatus, ...auditNoReceiptDecisiveFact(verdict) };
   if (judgeStatus === "continue") {
     const fix = safelyRead(verdict, "fix");
     if (fix.readable && isRecord(fix.value)) {
@@ -1015,7 +1026,7 @@ function collectorDecisiveFacts(
 function doctorDecisiveFacts(output: DoctorOutput): Record<string, unknown> {
   const candidate = output as unknown as object;
   const status = safelyRead(candidate, "status");
-  const facts: Record<string, unknown> = {};
+  const facts: Record<string, unknown> = { ...auditNoReceiptDecisiveFact(candidate) };
   if (status.readable && typeof status.value === "string") facts.doctorStatus = status.value;
   if (status.readable && status.value === "refused") {
     const reason = safelyRead(candidate, "reason");
@@ -1058,6 +1069,7 @@ function reviewerDecisiveFacts(
     axes,
     reportAxes,
     acceptedBatchPresent: acceptedBatch.readable && acceptedBatch.value !== undefined,
+    ...auditNoReceiptDecisiveFact(candidate),
   };
   if (status.readable && typeof status.value === "string") facts.reviewerStatus = status.value;
   const diagnostic = safelyRead(candidate, "diagnostic");
@@ -3668,6 +3680,33 @@ export async function settleFailureTerminalResult(
   failure: ControlledFailure,
   options: { readonly resume?: TerminalResume } = {},
 ): Promise<TerminalResult> {
+  // #288 is lawful only when the lifecycle owner persisted an exhausted,
+  // current-attempt fact. Transcript reconstruction must not turn arbitrary output
+  // failures (or bytes retained from a prior resume attempt) into exit zero.
+  if (failure.cause === "output") {
+    const entries = await readBoundSessionEntries(admitted.sessionFile).catch(() => undefined);
+    if (entries !== undefined) {
+      let attemptStart = 0;
+      for (let index = entries.length - 1; index >= 0; index -= 1) {
+        if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") { attemptStart = index; break; }
+      }
+      const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry: SessionEntry) =>
+        entry.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE || entry.message?.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE);
+      const raw = lifecycleEntry?.data ?? lifecycleEntry?.message?.details;
+      if (raw !== undefined) {
+        try {
+          const facts = parseNoReceiptLifecycleFacts(raw);
+          if (facts.runPointer === admitted.runDirectory && facts.attemptPointer === `current:${admitted.runDirectory}`) {
+            const decisiveFacts: NoReceiptLifecycleFacts = facts;
+            return {
+              roleOutcome: { kind: "no_receipt", role: admitted.role, status: "no-accepted-receipt", ...facts, decisiveFacts },
+              navigator: await extractNavigatorFactFromAdmittedSession(admitted), artifacts: [], runId: admitted.runId,
+            };
+          }
+        } catch { /* malformed lifecycle bytes remain the existing nonzero output failure */ }
+      }
+    }
+  }
   // Exact-session attendance only — never infer no-advice from caller omission.
   const navigator = await extractNavigatorFactFromAdmittedSession(admitted);
   // Private durable artifacts retain the original diagnostic identity (including run ID).
@@ -3741,16 +3780,16 @@ export function presentFailureTerminal(
   terminal: TerminalResult,
   io: { stdout: (text: string) => void; stderr: (text: string) => void },
 ): void {
-  if (terminal.roleOutcome.kind !== "failure") {
-    throw new TypeError("presentFailureTerminal requires a failure role outcome");
+  if (terminal.roleOutcome.kind !== "failure" && terminal.roleOutcome.kind !== "no_receipt") {
+    throw new TypeError("presentFailureTerminal requires a failure or no-receipt role outcome");
   }
   io.stdout(formatTerminalResult(terminal));
-  io.stderr(
-    formatFailureStderrDiagnostic({
+  if (terminal.roleOutcome.kind === "failure") {
+    io.stderr(formatFailureStderrDiagnostic({
       cause: terminal.roleOutcome.cause,
       diagnostic: terminal.roleOutcome.diagnostic,
-    }),
-  );
+    }));
+  }
 }
 
 /**

package/src/public-cli/terminal.ts

@@ -8,6 +8,7 @@
 import { renderPublicAkRoleCommand } from "./command-renderer.ts";
 import type { ComplianceAuditIncomplete } from "../compliance-transport.ts";
 import type { NavigatorPhase } from "../navigator-attendance.ts";
+import type { NoReceiptLifecycleFacts } from "../receipt-delivery-policy.ts";
 
 /** Encode one free-text Terminal cell. JSON string form cannot embed raw tab/newline. */
 export function encodeTerminalField(value: string): string {
@@ -79,6 +80,13 @@ export function jsonSafeComplianceCandidate(value: unknown): unknown {
   return value === undefined ? JSON_SAFE_UNDEFINED_ARGUMENT : value;
 }
 
+export type NoReceiptTerminalOutcome = NoReceiptLifecycleFacts & {
+  kind: "no_receipt";
+  role: TerminalRoleName;
+  status: "no-accepted-receipt";
+  decisiveFacts: NoReceiptLifecycleFacts & Readonly<Record<string, unknown>>;
+};
+
 export type TerminalRoleOutcome =
   | {
       kind: "accepted";
@@ -95,6 +103,7 @@ export type TerminalRoleOutcome =
     }
   | AuditIncompleteTerminalOutcome
   | ResidualIncompleteTerminalOutcome
+  | NoReceiptTerminalOutcome
   | {
       kind: "failure";
       role: TerminalRoleName;
@@ -111,7 +120,7 @@ export type TerminalRoleOutcome =
 export function isLawfulTypedTerminalOutcome(
   outcome: TerminalRoleOutcome,
 ): boolean {
-  return outcome.kind === "accepted" || outcome.kind === "audit_escalation";
+  return outcome.kind === "accepted" || outcome.kind === "audit_escalation" || outcome.kind === "no_receipt";
 }
 
 export function exitCodeForTerminalOutcome(

package/src/receipt-delivery-policy.ts

@@ -0,0 +1,89 @@
+/** Shared accepted-receipt delivery budget for role, auditor, and Navigator sessions (#288). */
+export const RECEIPT_DELIVERY_TURN_LIMIT = 2 as const;
+export const RECEIPT_DELIVERY_PROMPT = "本 session 尚无已接受的 typed 回执。请现在调用具名终局工具交卷；若先前被打回，请按拒因修正后重交。";
+
+export const NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle" as const;
+
+/** The sole schema shared by lifecycle owners and Terminal projections. */
+export type NoReceiptLifecycleFacts = {
+  terminalToolCalled: boolean;
+  rejectedReceipts: readonly { reason: string }[];
+  deliveryTurns: typeof RECEIPT_DELIVERY_TURN_LIMIT;
+  sessionCompletion: "settled-without-accepted-receipt";
+  runPointer: string;
+  attemptPointer: string;
+  acceptedReceipt: false;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Read only the facts required by Terminal consumers; persisted extensions are ignored. */
+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() === ""
+    || typeof input.attemptPointer !== "string" || input.attemptPointer.trim() === ""
+    || !Array.isArray(input.rejectedReceipts)
+    || !input.rejectedReceipts.every((item) => isRecord(item)
+      && typeof item.reason === "string" && item.reason.trim() !== "")) {
+    throw new TypeError("malformed no-receipt lifecycle facts");
+  }
+  return {
+    terminalToolCalled: input.terminalToolCalled,
+    rejectedReceipts: input.rejectedReceipts.map((item) => ({ reason: item.reason as string })),
+    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+    sessionCompletion: "settled-without-accepted-receipt",
+    runPointer: input.runPointer,
+    attemptPointer: input.attemptPointer,
+    acceptedReceipt: false,
+  };
+}
+
+export function noReceiptLifecycleFacts(
+  input: Omit<NoReceiptLifecycleFacts, "deliveryTurns" | "sessionCompletion" | "acceptedReceipt"> & { 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 })),
+    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+    sessionCompletion: "settled-without-accepted-receipt",
+    runPointer: input.runPointer,
+    attemptPointer: input.attemptPointer,
+    acceptedReceipt: false,
+  };
+}
+
+export function createReceiptDeliveryPolicy() {
+  let accepted = false;
+  let terminalToolCalled = false;
+  let deliveryTurns = 0;
+  const rejectedReceipts: { reason: string }[] = [];
+  return {
+    recordAccepted() { accepted = true; terminalToolCalled = true; },
+    /** Infrastructure owns terminality and must never trigger receipt催交. */
+    stopForInfrastructure() { accepted = true; },
+    recordRejected(reason: string) {
+      terminalToolCalled = true;
+      rejectedReceipts.push({ reason });
+      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
+    },
+    recordDeliveryRequest() {
+      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
+    },
+    nextAction(): "accepted" | "request-delivery" | "no-receipt" {
+      if (accepted) return "accepted";
+      return deliveryTurns < RECEIPT_DELIVERY_TURN_LIMIT ? "request-delivery" : "no-receipt";
+    },
+    facts(binding: { runPointer: string; attemptPointer: string }): NoReceiptLifecycleFacts {
+      return noReceiptLifecycleFacts({ terminalToolCalled, rejectedReceipts: [...rejectedReceipts], deliveryTurns, ...binding });
+    },
+  };
+}

package/src/reviewer-role.ts

@@ -163,6 +163,10 @@ export function createReviewerRoleRuntime(pi: ExtensionAPI, dependencies: Review
                 try { await dependencies.shutdownAgent?.(); } catch (error) { hostActions.failInfrastructure(ledger.recordInfrastructureFailure(error), toolCtx, id); }
                 return { content: [{ type: "text" as const, text: "Reviewer report accepted" }], details: candidate, terminate: true as const, ...(usage === undefined ? {} : { usage }) };
               },
+              noReceipt: async (auditNoReceipt) => {
+                try { await dependencies.shutdownAgent?.(); } catch (error) { hostActions.failInfrastructure(ledger.recordInfrastructureFailure(error), toolCtx, id); }
+                return { content: [{ type: "text" as const, text: "Reviewer report accepted; compliance audit produced no receipt" }], details: { ...candidate, auditNoReceipt }, terminate: true as const };
+              },
               revise: (violations) => {
                 throw new AggregateError([], `Reviewer receipt rejected:\n${violations.join("\n")}`, { cause: Object.freeze([...violations]) });
               },

package/src/role-runtime.ts

@@ -23,6 +23,7 @@ import {
 } from "./tool-execution-observation.ts";
 import { installPackageOwnedToolRegistration } from "./package-owned-tool-idle.ts";
 import { installWorkerGitHooks } from "./worker-submission-gates.ts";
+import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_PROMPT } from "./receipt-delivery-policy.ts";
 
 import type { AnyCanonicalSkillBinding } from "./canonical-skill-binding.ts";
 import type { CollectorClock } from "./collector-evidence.ts";
@@ -426,6 +427,10 @@ export function createRoleRuntimeExtension(
     let pendingNavigatorSettlement: Promise<void> | undefined;
     let navigatorWorkContext: NavigatorWorkContext | undefined;
     const pendingInfrastructureToolCallIds = new Set<string>();
+    // #288 primary-session thin adapter. The policy is the sole budget owner;
+    // terminating-tool rejections and mechanical delivery requests share two turns.
+    let receiptDelivery = createReceiptDeliveryPolicy();
+    let noReceiptRecorded = false;
     pi.on("input", () => {
       const role = pi.getFlag(ROLE_FLAG.name);
       if (role !== undefined && !admitted) return { action: "handled" as const };
@@ -467,7 +472,7 @@ export function createRoleRuntimeExtension(
     });
     pi.on("tool_result", async (event) => {
       const role = selectedRole;
-      if (role === undefined || navigatorAttendance === undefined) return;
+      if (role === undefined) return;
       const isRoleInfrastructureFailure = pendingInfrastructureToolCallIds.delete(event.toolCallId);
       // Overlay typed infra fact so live settlement and durable session entry agree.
       const infrastructureDetails = isRoleInfrastructureFailure
@@ -476,6 +481,19 @@ export function createRoleRuntimeExtension(
       const classified = infrastructureDetails === undefined
         ? event
         : { ...event, details: infrastructureDetails };
+      const isOutputTool = event.toolName === navigatorOutputTool(role);
+      const outputClassification = isOutputTool ? classifyPackagedRoleTerminalResult(classified) : undefined;
+      if (isRoleInfrastructureFailure || outputClassification?.kind === "infrastructure") {
+        receiptDelivery.stopForInfrastructure();
+      } else if (outputClassification?.kind === "accepted") {
+        receiptDelivery.recordAccepted();
+      } else if (isOutputTool && outputClassification?.kind === "nonterminal" && event.isError) {
+        const reason = (event.content ?? [])
+          .map((part) => part.type === "text" ? part.text : "")
+          .join("")
+          .trim() || "terminating tool rejected";
+        receiptDelivery.recordRejected(reason);
+      }
       const settlement = publicNavigatorSettlement(
         role,
         navigatorPhase(pi, role),
@@ -483,8 +501,9 @@ export function createRoleRuntimeExtension(
       );
       if (settlement !== undefined) {
         const attendance = navigatorAttendance;
-        const workContext = navigatorWorkContext;
-        const pending = (async () => {
+        if (attendance !== undefined) {
+          const workContext = navigatorWorkContext;
+          const pending = (async () => {
           // Accepted role terminal starts the post-role Navigator grace (#101/#106).
           if (settlement.kind !== "accepted") {
             await attendance.settle(settlement);
@@ -522,8 +541,9 @@ export function createRoleRuntimeExtension(
             void settlePromise.catch(() => undefined);
           }
         })();
-        pendingNavigatorSettlement = pending;
-        await pending;
+          pendingNavigatorSettlement = pending;
+          await pending;
+        }
       }
       // Persist typed infrastructure-failure fact onto the role session toolResult so
       // exact-session restart shares the same durable completion classification.
@@ -541,6 +561,39 @@ export function createRoleRuntimeExtension(
         content: decorated.content as typeof event.content,
       };
     });
+    // Queue receipt delivery before `agent_settled`: that event means Pi has
+    // already decided no queued continuation will run, so a triggerTurn there is
+    // too late for print/json sessions. `agent_end` is the last production seam
+    // whose queued next turn is consumed before settlement.
+    pi.on("agent_end", (event) => {
+      const lastMessage = event.messages.at(-1);
+      if (lastMessage?.role === "assistant" && lastMessage.stopReason === "error") {
+        // Provider failure has no tool_result event; classify it here so the
+        // receipt policy cannot turn infrastructure death into an exit-0 lifecycle.
+        receiptDelivery.stopForInfrastructure();
+        return;
+      }
+      if (receiptDelivery.nextAction() === "request-delivery") {
+        receiptDelivery.recordDeliveryRequest();
+        // Keep the package-owned continuation off the public input lifecycle:
+        // one-shot roles must not mistake this delivery request for later caller input.
+        pi.appendEntry("ak-receipt-delivery-request");
+        pi.sendMessage({
+          customType: "ak-receipt-delivery-prompt",
+          content: RECEIPT_DELIVERY_PROMPT,
+          display: false,
+        }, { triggerTurn: true, deliverAs: "followUp" });
+      } else if (receiptDelivery.nextAction() === "no-receipt" && !noReceiptRecorded) {
+        const runPointer = process.env.AK_ROLE_RUN_DIR;
+        if (runPointer !== undefined) {
+          noReceiptRecorded = true;
+          pi.appendEntry(
+            NO_RECEIPT_LIFECYCLE_ENTRY_TYPE,
+            receiptDelivery.facts({ runPointer, attemptPointer: `current:${runPointer}` }),
+          );
+        }
+      }
+    });
     pi.on("agent_settled", async () => {
       if (pendingNavigatorSettlement !== undefined) {
         await pendingNavigatorSettlement;
@@ -774,6 +827,8 @@ export function createRoleRuntimeExtension(
     pi.on("session_start", async (event, ctx) => {
       admitted = false;
       selectedRole = undefined;
+      receiptDelivery = createReceiptDeliveryPolicy();
+      noReceiptRecorded = false;
       observationFace.reset();
       pendingNavigatorPresentation = undefined;
       pendingNavigatorSettlement = undefined;