@akagilnc/pi-workflow-roles 0.1.1817 → 0.1.1837

package/dist/audit-escalation.js

@@ -101,7 +101,7 @@ export async function disposeComplianceDecision(decision, handlers, deliveredOut
             if (handlers.noReceipt === undefined) {
                 throw new Error("Compliance no-receipt projection handler is unavailable");
             }
-            return await handlers.noReceipt(decision);
+            return await handlers.noReceipt(decision, decision.usage === undefined ? {} : { usage: decision.usage });
         case "revise":
             return await handlers.revise(decision.violations);
         case "escalate":

package/dist/compliance-transport.js

@@ -1,7 +1,6 @@
 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" });
@@ -74,10 +73,12 @@ export async function runComplianceAudit(options) {
         ...(options.runCompletion === undefined ? {} : { runCompletion: options.runCompletion }),
         ...(options.signal === undefined ? {} : { signal: options.signal }),
     });
-    try {
-        return { status: "no-receipt", ...parseNoReceiptLifecycleFacts(receipt.decision) };
-    }
-    catch {
-        return readComplianceCandidate(receipt.decision, receipt.response.usage);
+    if (receipt.noReceiptLifecycle !== undefined) {
+        return {
+            status: "no-receipt",
+            ...receipt.noReceiptLifecycle,
+            ...(receipt.response.usage === undefined ? {} : { usage: receipt.response.usage }),
+        };
     }
+    return readComplianceCandidate(receipt.decision, receipt.response.usage);
 }

package/dist/evidence-child-executor.js

@@ -428,10 +428,12 @@ export async function executeAuditorChild(options) {
         });
         const cwd = options.context.cwd ?? process.cwd();
         let decision;
+        let noReceiptLifecycle;
         let decisionSubmitted = false;
         let decisionCallId;
         let decisionToolFailure;
         const decisionToolFailures = new Map();
+        const delivery = createReceiptDeliveryPolicy();
         const tool = wrapPackageOwnedToolDefinition({
             ...options.tool,
             label: options.roleLabel,
@@ -439,8 +441,12 @@ export async function executeAuditorChild(options) {
                 if (decisionSubmitted && decisionCallId !== args[0]) {
                     throw new Error("Auditor decision was submitted more than once");
                 }
+                // Pi may already have issued several decision calls in one assistant
+                // response. Execute every issued call: the budget limits future
+                // solicitations, not terminal calls already in flight.
                 try {
                     const result = await options.tool.execute(...args);
+                    delivery.recordAccepted();
                     decision = args[1];
                     decisionCallId = args[0];
                     decisionToolFailure = undefined;
@@ -490,11 +496,13 @@ export async function executeAuditorChild(options) {
         // response could not later be tied to the current parent attempt.
         auditorSessionManager.appendCustomEntry(AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE, binding);
         let turns = 0;
+        const sessionUsage = emptyUsage();
         let boundaryResponse;
         let retentionFailure;
         let retainedResponse;
         let rejectedDecisionResponse;
         let promptNeighboringFailure;
+        let promptDecisionFailures = [];
         const registeredToolNames = new Set(session.getAllTools().map((entry) => entry.name));
         const evidenceToolFailures = new Map();
         for (const name of registeredToolNames) {
@@ -523,9 +531,19 @@ export async function executeAuditorChild(options) {
             const callIdSet = new Set(callIds);
             return [...session.messages].reverse().find((message) => message.role === "toolResult" && callIdSet.has(message.toolCallId) && message.isError);
         };
+        const drainRejectedDecisionFailures = (response) => {
+            for (const part of response.content) {
+                if (part.type !== "toolCall" || part.name !== tool.name || !decisionToolFailures.has(part.id))
+                    continue;
+                decisionToolFailure = decisionToolFailures.get(part.id);
+                promptDecisionFailures.push(decisionToolFailure);
+                decisionToolFailures.delete(part.id);
+            }
+        };
         const unsubscribe = session.subscribe((event) => {
             if (event.type === "message_end" && event.message.role === "assistant" && boundaryResponse === undefined) {
                 turns += 1;
+                addUsage(sessionUsage, event.message.usage);
                 retainedResponse = event.message;
                 try {
                     options.retainResponse?.(event.message);
@@ -556,14 +574,11 @@ export async function executeAuditorChild(options) {
             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);
-                    }
+                    drainRejectedDecisionFailures(rejectedDecisionResponse);
                 }
                 if (decisionSubmitted || promptNeighboringFailure !== undefined
-                    || boundaryResponse !== undefined || retentionFailure !== undefined) {
+                    || (boundaryResponse !== undefined && rejectedDecisionResponse === undefined)
+                    || retentionFailure !== undefined) {
                     void session.abort();
                 }
             }
@@ -575,11 +590,11 @@ export async function executeAuditorChild(options) {
             options.signal?.addEventListener("abort", abort, { once: true });
         try {
             try {
-                const delivery = createReceiptDeliveryPolicy();
                 const promptAllowingRejectedDecision = async (prompt) => {
                     rejectedDecisionResponse = undefined;
                     promptNeighboringFailure = undefined;
                     decisionToolFailure = undefined;
+                    promptDecisionFailures = [];
                     let promptFailure;
                     try {
                         await session.prompt(prompt);
@@ -593,28 +608,47 @@ export async function executeAuditorChild(options) {
                     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);
-                        }
+                        drainRejectedDecisionFailures(correlatedResponse);
                     }
                     // An adjacent failure outranks correctable decision feedback.
                     if (promptNeighboringFailure !== undefined)
                         throw promptNeighboringFailure;
+                    // An accepted correction in the same response owns the terminal
+                    // outcome; correlated rejected siblings remain observations, not a
+                    // stale failure capable of replacing that accepted receipt.
+                    if (decisionSubmitted) {
+                        decisionToolFailure = undefined;
+                        return;
+                    }
                     if (decisionToolFailure !== undefined)
                         return;
                     if (promptFailure !== undefined)
                         throw promptFailure;
                 };
+                const chargeAndClearRejectedDecisionFailures = (failures) => {
+                    for (const failure of failures) {
+                        delivery.recordRejected(failure instanceof Error ? failure.message : String(failure));
+                    }
+                    decisionToolFailure = undefined;
+                    promptDecisionFailures = [];
+                };
                 await promptAllowingRejectedDecision(options.prompt);
-                while (!decisionSubmitted && boundaryResponse === undefined && inherited.streamFailure === undefined
-                    && delivery.nextAction() === "request-delivery") {
+                while (!decisionSubmitted && (boundaryResponse === undefined || decisionToolFailure !== undefined)
+                    && inherited.streamFailure === undefined && delivery.nextAction() === "request-delivery") {
                     if (decisionToolFailure !== undefined) {
-                        delivery.recordRejected(decisionToolFailure instanceof Error ? decisionToolFailure.message : String(decisionToolFailure));
-                        decisionToolFailure = undefined;
+                        const failures = promptDecisionFailures.length === 0
+                            ? [decisionToolFailure]
+                            : promptDecisionFailures;
+                        chargeAndClearRejectedDecisionFailures(failures);
+                        if (delivery.nextAction() === "no-receipt")
+                            boundaryResponse = undefined;
                         if (delivery.nextAction() === "request-delivery") {
-                            await promptAllowingRejectedDecision(RECEIPT_DELIVERY_PROMPT);
+                            // A rejection and its correction solicitation are one budget unit;
+                            // recordRejected already charged it.
+                            if (retainedResponse === rejectedDecisionResponse) {
+                                await promptAllowingRejectedDecision(RECEIPT_DELIVERY_PROMPT);
+                                chargeAndClearRejectedDecisionFailures(promptDecisionFailures);
+                            }
                         }
                     }
                     else {
@@ -622,15 +656,19 @@ export async function executeAuditorChild(options) {
                         await promptAllowingRejectedDecision(RECEIPT_DELIVERY_PROMPT);
                     }
                 }
-                if (!decisionSubmitted && boundaryResponse === undefined && inherited.streamFailure === undefined
+                if (!decisionSubmitted && 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 });
+                    const facts = delivery.facts({ runPointer, attemptPointer });
+                    decision = facts;
                     // 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);
+                    auditorSessionManager.appendCustomEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
+                    // Provenance is granted only after the lifecycle owner persisted the
+                    // current child record; accepted model arguments can never set it.
+                    noReceiptLifecycle = facts;
                 }
             }
             catch (error) {
@@ -644,7 +682,7 @@ export async function executeAuditorChild(options) {
                 throw options.signal.reason;
             if (inherited.streamFailure !== undefined)
                 throw inherited.streamFailure;
-            if (decisionToolFailure !== undefined)
+            if (!decisionSubmitted && decisionToolFailure !== undefined)
                 throw decisionToolFailure;
             const relevantResponse = !decisionSubmitted
                 ? boundaryResponse
@@ -656,7 +694,7 @@ export async function executeAuditorChild(options) {
             }
             if (retentionFailure !== undefined && retainedResponse?.stopReason !== "error")
                 throw retentionFailure;
-            if (boundaryResponse !== undefined && !decisionSubmitted) {
+            if (boundaryResponse !== undefined && !decisionSubmitted && noReceiptLifecycle === undefined) {
                 const toolNames = boundaryResponse.content.flatMap((part) => part.type === "toolCall" ? [part.name] : []);
                 throw new AuditorTurnLimitError(AUDITOR_TURN_LIMIT, turns, {
                     stopReason: boundaryResponse.stopReason,
@@ -728,7 +766,11 @@ export async function executeAuditorChild(options) {
                 || (!decisionSubmitted && decision === undefined)) {
                 throw new Error(`${options.roleLabel} exited without a readable decision receipt`);
             }
-            return { decision, response };
+            return {
+                decision,
+                response: { ...response, usage: sessionUsage },
+                ...(noReceiptLifecycle === undefined ? {} : { noReceiptLifecycle }),
+            };
         }
         finally {
             options.signal?.removeEventListener("abort", abort);

package/dist/navigator-attendance.js

@@ -438,8 +438,13 @@ function createNavigatorAttendance(options) {
 ${text}
 </role_help>`).join("\n");
     let output;
+    let prepareBatchRejected = false;
     outputSink = (value) => {
-      if (output !== void 0) throw new Error("Navigator preparation must submit exactly one typed candidate batch");
+      if (prepareBatchRejected || output !== void 0) {
+        output = void 0;
+        prepareBatchRejected = true;
+        throw new Error("Navigator preparation must submit exactly one typed candidate batch");
+      }
       output = value;
     };
     const tool = createNavigatorPrepareTool((value) => {
@@ -553,6 +558,7 @@ ${helpContext}
         const delivery = createReceiptDeliveryPolicy();
         const promptAllowingRejectedPrepare = async (text, deliveryRequest) => {
           const entryStart = activeSession.entries().length;
+          prepareBatchRejected = false;
           let promptFailure;
           try {
             await activeSession.prompt(text);
@@ -565,6 +571,8 @@ ${helpContext}
           }
           const rejectedReason = rejectedPrepareReason(activeSession.entries(), entryStart);
           if (rejectedReason !== void 0) {
+            output = void 0;
+            prepareBatchRejected = true;
             delivery.recordRejected(rejectedReason);
             return;
           }