@akagilnc/pi-workflow-roles 0.1.1794 → 0.1.1815

package/dist/audit-escalation.js

@@ -95,6 +95,13 @@ export async function disposeComplianceDecision(decision, handlers, deliveredOut
     switch (decision.status) {
         case "pass":
             return await handlers.pass(decision.usage);
+        case "no-receipt":
+            // The parent candidate remains accepted, but its parallel audit leg is a
+            // public typed fact and must not be collapsed into an ordinary pass.
+            if (handlers.noReceipt === undefined) {
+                throw new Error("Compliance no-receipt projection handler is unavailable");
+            }
+            return await handlers.noReceipt(decision);
         case "revise":
             return await handlers.revise(decision.violations);
         case "escalate":

package/dist/compliance-transport.js

@@ -1,6 +1,7 @@
 import { Type } from "typebox";
 import { executeAuditorChild, } from "./evidence-child-executor.js";
 import { createAuditorDossierTool } from "./auditor-dossier-tool.js";
+import { parseNoReceiptLifecycleFacts } from "./receipt-delivery-policy.js";
 /** Zero-projection kickoff — soul already carries dossier-fetch duty; no hand-delivered materials. */
 export const AUDITOR_DOSSIER_PROMPT = "Audit the current run dossier.";
 const nonblank = Type.String({ minLength: 1, pattern: "\\S" });
@@ -73,5 +74,10 @@ export async function runComplianceAudit(options) {
         ...(options.runCompletion === undefined ? {} : { runCompletion: options.runCompletion }),
         ...(options.signal === undefined ? {} : { signal: options.signal }),
     });
-    return readComplianceCandidate(receipt.decision, receipt.response.usage);
+    try {
+        return { status: "no-receipt", ...parseNoReceiptLifecycleFacts(receipt.decision) };
+    }
+    catch {
+        return readComplianceCandidate(receipt.decision, receipt.response.usage);
+    }
 }

package/dist/evidence-child-executor.js

@@ -10,6 +10,7 @@ import { createAssistantMessageEventStream, InMemoryCredentialStore, } from "@ea
 import { AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE, AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE, prepareComplianceDispatch, } from "./compliance-transport.js";
 import { wrapPackageOwnedToolDefinition } from "./package-owned-tool-idle.js";
 import { createStreamIdleGuard, isStreamIdleTimeoutError } from "./stream-idle-guard.js";
+import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_PROMPT } from "./receipt-delivery-policy.js";
 // ── shared constants / types ──────────────────────────────────────────────
 export const AUDITOR_TURN_LIMIT = 32;
 export const DEFAULT_COMPLIANCE_IDLE_MAX_RETRIES = 2;
@@ -430,6 +431,7 @@ export async function executeAuditorChild(options) {
         let decisionSubmitted = false;
         let decisionCallId;
         let decisionToolFailure;
+        const decisionToolFailures = new Map();
         const tool = wrapPackageOwnedToolDefinition({
             ...options.tool,
             label: options.roleLabel,
@@ -441,11 +443,14 @@ export async function executeAuditorChild(options) {
                     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;
                 }
             },
@@ -488,6 +493,8 @@ export async function executeAuditorChild(options) {
         let boundaryResponse;
         let retentionFailure;
         let retainedResponse;
+        let rejectedDecisionResponse;
+        let promptNeighboringFailure;
         const registeredToolNames = new Set(session.getAllTools().map((entry) => entry.name));
         const evidenceToolFailures = new Map();
         for (const name of registeredToolNames) {
@@ -526,24 +533,39 @@ export async function executeAuditorChild(options) {
                 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(); };
@@ -553,7 +575,63 @@ export async function executeAuditorChild(options) {
             options.signal?.addEventListener("abort", abort, { once: true });
         try {
             try {
-                await session.prompt(options.prompt);
+                const delivery = createReceiptDeliveryPolicy();
+                const promptAllowingRejectedDecision = async (prompt) => {
+                    rejectedDecisionResponse = undefined;
+                    promptNeighboringFailure = undefined;
+                    decisionToolFailure = undefined;
+                    let promptFailure;
+                    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;
+                    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)
@@ -647,7 +725,7 @@ export async function executeAuditorChild(options) {
             if (response === undefined
                 || response.stopReason === "error"
                 || response.stopReason === "aborted"
-                || !decisionSubmitted) {
+                || (!decisionSubmitted && decision === undefined)) {
                 throw new Error(`${options.roleLabel} exited without a readable decision receipt`);
             }
             return { decision, response };

package/dist/navigator-attendance.js

@@ -17,6 +17,7 @@ import { openInProcessAgentSession } from "./in-process-session.js";
 import { renderPublicAkRoleCommand } from "./public-command-renderer.js";
 import { issueRoot, subjectPath } from "./work-subject-identity.js";
 import { wrapPackageOwnedToolDefinition } from "./package-owned-tool-idle.js";
+import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_PROMPT } from "./receipt-delivery-policy.js";
 const NAVIGATOR_EVENT_TYPE = "ak-navigator-attendance";
 const NAVIGATOR_PREPARE_TOOL_NAME = "ak_navigator_prepare";
 const NAVIGATOR_DEFAULT_MODEL = "openai-codex/gpt-5.6-luna:max";
@@ -105,6 +106,28 @@ function unavailableKey(value) {
 function exactRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function rejectedPrepareReason(entries, start) {
+  const recent = entries.slice(start);
+  const prepareCalls = /* @__PURE__ */ new Set();
+  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;
+  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 void 0;
+    }
+    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) {
   if (!exactRecord(value) || !targetRoles.has(String(value.role))) return false;
   const metadata = packagedRoleMetadata(String(value.role));
@@ -327,6 +350,7 @@ function createNavigatorAttendance(options) {
   let settlementTail = Promise.resolve();
   let settlementFailure;
   let preparationFailure;
+  let preparationNoReceipt = false;
   let routePlaybookReadFailure;
   let disposed = false;
   let warmedHelp;
@@ -526,7 +550,38 @@ ${helpContext}
     try {
       try {
         if (disposed) throw navigatorUnavailableError("session", new Error("Navigator attendance was disposed"));
-        await activeSession.prompt(request);
+        const delivery = createReceiptDeliveryPolicy();
+        const promptAllowingRejectedPrepare = async (text, deliveryRequest) => {
+          const entryStart = activeSession.entries().length;
+          let promptFailure;
+          try {
+            await activeSession.prompt(text);
+          } catch (error) {
+            promptFailure = error;
+          }
+          const providerFailure = activeSession.providerFailure?.();
+          if (providerFailure !== void 0) {
+            throw navigatorUnavailableError(providerFailure.source, promptFailure ?? "Navigator provider failure", providerFailure.cause);
+          }
+          const rejectedReason = rejectedPrepareReason(activeSession.entries(), entryStart);
+          if (rejectedReason !== void 0) {
+            delivery.recordRejected(rejectedReason);
+            return;
+          }
+          if (promptFailure !== void 0) throw promptFailure;
+          if (deliveryRequest && output === void 0) delivery.recordDeliveryRequest();
+        };
+        await promptAllowingRejectedPrepare(request, false);
+        while (output === void 0 && delivery.nextAction() === "request-delivery") {
+          await promptAllowingRejectedPrepare(RECEIPT_DELIVERY_PROMPT, true);
+        }
+        if (output === void 0 && delivery.nextAction() === "no-receipt" && activeSession.providerFailure?.() === void 0) {
+          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);
       }
@@ -655,22 +710,25 @@ ${helpContext}
             throw new Error("Navigator advice contradicts the accepted settlement");
           }
         }
-        if (selected?.next === void 0) {
+        if (selected?.next === void 0 && preparationNoReceipt) {
+          report = { disposition: "no-advice" };
+        } else if (selected?.next === void 0) {
           throw new Error("Navigator prepared no machine-usable next direction");
-        }
-        const selectedRoute = selected.route;
-        const routeChanged = selectedRoute !== void 0 && !routeEqual(previousRoute, selectedRoute);
-        const command = renderPublicAkRoleCommand(selected.next);
-        report = {
-          disposition: "recommendation",
-          ...routeChanged ? { route: selectedRoute } : {},
-          next: selected.next,
-          ...selected.reason === void 0 ? {} : { reason: oneLine(selected.reason) },
-          ...command === void 0 ? {} : { command }
-        };
-        if (selectedRoute !== void 0) {
-          previousRoute = selectedRoute;
-          session?.appendEntry(ROUTE_ENTRY, { invocationId, subjectKey, route: selectedRoute });
+        } else {
+          const selectedRoute = selected.route;
+          const routeChanged = selectedRoute !== void 0 && !routeEqual(previousRoute, selectedRoute);
+          const command = renderPublicAkRoleCommand(selected.next);
+          report = {
+            disposition: "recommendation",
+            ...routeChanged ? { route: selectedRoute } : {},
+            next: selected.next,
+            ...selected.reason === void 0 ? {} : { reason: oneLine(selected.reason) },
+            ...command === void 0 ? {} : { command }
+          };
+          if (selectedRoute !== void 0) {
+            previousRoute = selectedRoute;
+            session?.appendEntry(ROUTE_ENTRY, { invocationId, subjectKey, route: selectedRoute });
+          }
         }
       } catch (error) {
         report = unavailable(invocationId, error);
@@ -704,6 +762,7 @@ ${helpContext}
     sessionReady = void 0;
     candidates = void 0;
     preparationFailure = void 0;
+    preparationNoReceipt = false;
     routePlaybookSettlement = void 0;
     routePlaybookReadFailure = void 0;
   }