@akagilnc/pi-workflow-roles 0.1.5406 → 0.1.5475

package/dist/public-cli/instruction-seat-run.js

@@ -29,12 +29,13 @@ import { packagedAdmitsCountersign, packagedBindsBoardTicket, packagedRebindSour
 import { readAuditorResumeBinding } from "../auditor-soul.js";
 import { CliUsageError } from "./cli-errors.js";
 import { admitPublicRole, bindAdmittedTicketNumber, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, withPreparedAttachments, } from "./invocation.js";
-import { presentControlledFailure, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
+import { presentControlledFailure, packageFaultNoteFor, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
+import { presentTerminal } from "./auto-resume.js";
 import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, parentRunPathFromGatePointerInstruction, readCurrentCourt, } from "./run-lifecycle.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
-import { presentStructuralRejection, readBoundSessionEntries, seatKnownFailureResolver, attachPostAuditProjection, trySettlePublicSeat, } from "./settlement.js";
+import { presentStructuralRejection, readBoundSessionEntries, attachPostAuditProjection, trySettlePublicSeat, } from "./settlement.js";
 import { warnMissingMethodSkills } from "./machine-method-skills.js";
-import { coalesceSubmissionRows, formatTerminalResult, isLawfulTypedTerminalOutcome, } from "./terminal.js";
+import { formatTerminalResult, isLawfulTypedTerminalOutcome, } from "./terminal.js";
 import { admittedSeatTurnDetails, projectRoleTurnRequest, requiredMethodSkills, } from "./turn-request.js";
 import { invokeCourtDiarist, latestPayloadEscalated, } from "./countersign-run.js";
 import { isRecord, errorText } from "../unknown-value.js";
@@ -98,19 +99,15 @@ const UNREADABLE_REASK_EXHAUSTED = { unreadableReaskExhausted: true };
 function isUnreadableReaskExhausted(value) {
     return value === UNREADABLE_REASK_EXHAUSTED;
 }
-function presentOriginalVolume(held, terminal, io) {
-    // The held buffer was formatted before direction facts were attached.
-    if (terminal?.roleOutcome.decisiveFacts?.directionUnsettled === true) {
-        io.stdout(formatTerminalResult(terminal));
-        return;
-    }
-    if (held.length > 0) {
-        for (const value of held)
-            io.stdout(value);
+async function presentOriginalVolume(held, terminal, io, runDirectory) {
+    if (terminal !== undefined && runDirectory !== undefined) {
+        // Direction facts were attached after the held volume was formatted.
+        await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, runDirectory, terminal.roleOutcome.decisiveFacts?.directionUnsettled === true ? undefined : held);
         return;
     }
-    if (terminal !== undefined)
-        io.stdout(formatTerminalResult(terminal));
+    // No settled host report exists to preserve at this pre-result boundary.
+    for (const value of held)
+        io.stdout(value);
 }
 /** Runtime fact beside the original volume. Payloads stay as submitted. */
 function withUnsettledDirection(parent, officer) {
@@ -118,9 +115,11 @@ function withUnsettledDirection(parent, officer) {
     if (outcome.kind !== "accepted" && outcome.kind !== "audit_escalation")
         return parent;
     const officerOutcome = officer?.roleOutcome;
-    const officerPayloads = coalesceSubmissionRows(officer?.submissions, officerOutcome !== undefined && officerOutcome.kind !== "no_receipt"
-        ? officerOutcome.payloads
-        : undefined);
+    const officerPayloads = officer?.submissions !== undefined && officer.submissions.length > 0
+        ? officer.submissions
+        : officerOutcome !== undefined && officerOutcome.kind !== "no_receipt"
+            ? officerOutcome.payloads ?? []
+            : [];
     return {
         ...parent,
         roleOutcome: {
@@ -144,11 +143,11 @@ function heldUnreadableTerminal(terminal) {
     const status = latestQueueStatus(terminal);
     return typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status);
 }
-function presentUnsettledAudit(parent, officer, io) {
+async function presentUnsettledAudit(parent, officer, io, runDirectory) {
     const terminal = withUnsettledDirection(parent, officer);
-    io.stdout(formatTerminalResult(terminal));
+    await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, runDirectory);
     if (officer !== undefined)
-        io.stdout(formatTerminalResult(officer));
+        await presentTerminal(officer, { ...io, omitFailureStderrDiagnostic: true }, runDirectory);
     return terminal;
 }
 async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io, message = unreadablePostSubmissionStatus(admitted, terminal)) {
@@ -157,7 +156,7 @@ async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io,
     const next = withUnreadableReask(env);
     if (next === undefined)
         return UNREADABLE_REASK_EXHAUSTED;
-    return runPublicInstructionSeatResume({ runId: admitted.runId, message }, next, io);
+    return runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction: message } }, next, io);
 }
 function roleRecord(role) {
     const record = packagedRoleMetadata(role);
@@ -181,10 +180,6 @@ function initialPrompt(admitted, env) {
         packageRoot: env.packageRoot,
     }));
 }
-function infraFailure(role) {
-    const resolveRunnerKnownFailure = seatKnownFailureResolver(role);
-    return resolveRunnerKnownFailure === undefined ? {} : { resolveRunnerKnownFailure };
-}
 function isBoardTicketSeat(seat) {
     return packagedBindsBoardTicket(seat.role);
 }
@@ -197,6 +192,9 @@ async function bindAndRelocateDiarist(admitted, authority, lease) {
     }
     return await relocateAdmittedRunToTicket(admitted, authority, lease);
 }
+function packageFaultScope(admitted, env, io) {
+    return { notePackageFault: packageFaultNoteFor(admitted, env, io) };
+}
 function seatAdapters(admitted, env) {
     const record = roleRecord(admitted.role);
     const present = "presentSettled" in record ? record.presentSettled : "default";
@@ -206,7 +204,6 @@ function seatAdapters(admitted, env) {
         ...(present === "typed"
             ? { shouldPresentSettled: (terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome) }
             : {}),
-        ...infraFailure(admitted.role),
         ...(packagedBindsBoardTicket(admitted.role)
             ? {
                 beforeDispatch: async (seat, lease) => {
@@ -309,7 +306,7 @@ async function dispatchAdmitted(admitted, env, io) {
         const terminal = result.terminal === undefined
             ? undefined
             : withUnsettledDirection(result.terminal);
-        presentOriginalVolume(held, terminal, io);
+        await presentOriginalVolume(held, terminal, io, admitted.runDirectory);
         return terminal === undefined ? result : { ...result, terminal };
     }
     if (unreadableReask !== undefined)
@@ -317,8 +314,7 @@ async function dispatchAdmitted(admitted, env, io) {
     if (AUDITED_ROLES.has(admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
         return auditSubmittedRole(result, env, io);
     }
-    for (const value of held)
-        io.stdout(value);
+    await presentOriginalVolume(held, result.terminal, io, admitted.runDirectory);
     return result;
 }
 /**
@@ -386,7 +382,11 @@ async function runOmittedLensBatch(argv, parsed, env, io) {
         },
         artifacts: terminals.flatMap((item) => item.artifacts),
     };
-    io.stdout(formatTerminalResult(terminal));
+    const childRunDirectory = children.completeness.admitted?.runDirectory ?? children.correctness.admitted?.runDirectory;
+    if (childRunDirectory !== undefined)
+        await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, childRunDirectory);
+    else
+        io.stdout(formatTerminalResult(terminal));
     return { exitCode: failed ? 1 : 0, terminal };
 }
 /**
@@ -522,8 +522,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         });
         if (result.terminal?.roleOutcome.kind === "accepted")
             return auditSubmittedRole(result, env, io);
-        for (const value of held)
-            io.stdout(value);
+        await presentOriginalVolume(held, result.terminal, io, result.admitted?.runDirectory);
         return result;
     }
     if ("parallelLenses" in record && record.parallelLenses === true) {
@@ -685,7 +684,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
             catch (error) {
                 return await presentControlledFailure(admitted, {
                     timedOut: false, code: null, stderr: "", thrown: error,
-                }, seatAdapters(admitted, env), env.principalAuthority, io);
+                }, seatAdapters(admitted, env), env.principalAuthority, io, true, packageFaultNoteFor(admitted, env, io));
             }
             if (outcome.admitted !== undefined && isUnboundRunDirectory(outcome.admitted.runDirectory)) {
                 await recordChildDiaristRun(admitted, outcome.admitted.runId);
@@ -694,12 +693,12 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
                 return await presentControlledFailure(admitted, {
                     timedOut: false, code: null, stderr: "",
                     thrown: new Error(outcome.failedWithoutEscalate.diagnostic),
-                }, seatAdapters(admitted, env), env.principalAuthority, io);
+                }, seatAdapters(admitted, env), env.principalAuthority, io, true, packageFaultNoteFor(admitted, env, io));
             }
             // The diarist's escalation pauses only the diarist's own run; call order
             // belongs to the caller, so the Secretariat still takes its own turn.
             if (outcome.identity.kind === "escalate" && outcome.terminal !== undefined) {
-                io.stdout(formatTerminalResult(outcome.terminal));
+                await presentTerminal(outcome.terminal, { ...io, omitFailureStderrDiagnostic: true }, outcome.admitted?.runDirectory ?? admitted.runDirectory);
             }
         }
         return dispatchAdmitted(admitted, env, io);
@@ -751,24 +750,7 @@ export async function runPublicInstructionSeatResume(request, env, io) {
             },
             afterAdmittedLoad: async (admitted) => {
                 await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
-                const adapters = seatAdapters(admitted, env);
-                if ((env.unreadableReasksSpent ?? 0) === 0 && env.reviewReask === undefined) {
-                    return { kind: "continue", adapters };
-                }
-                const original = await adapters.trySettle(admitted, env.principalAuthority, await readCurrentCourt(admitted.runDirectory));
-                const unsettled = POST_SUBMISSION_ROUTING[admitted.role] === undefined
-                    ? heldUnreadableTerminal(original)
-                    : unreadablePostSubmissionStatus(admitted, original) !== undefined;
-                // Select this reask's existing subject before dispatch. The common
-                // settlement then keeps it only when no fresh receipt supersedes it;
-                // actual failures still take their normal failure path.
-                return {
-                    kind: "continue",
-                    adapters: original === undefined || !unsettled ? adapters : {
-                        ...adapters,
-                        trySettle: async (seat, authority, scope) => await adapters.trySettle(seat, authority, scope) ?? original,
-                    },
-                };
+                return { kind: "continue", adapters: seatAdapters(admitted, env) };
             },
             ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
         });
@@ -779,7 +761,7 @@ export async function runPublicInstructionSeatResume(request, env, io) {
             const terminal = result.terminal === undefined
                 ? undefined
                 : withUnsettledDirection(result.terminal);
-            presentOriginalVolume(held, terminal, io);
+            await presentOriginalVolume(held, terminal, io, result.admitted?.runDirectory);
             return terminal === undefined ? result : { ...result, terminal };
         }
         if (unreadableReask !== undefined)
@@ -788,8 +770,7 @@ export async function runPublicInstructionSeatResume(request, env, io) {
             && result.terminal?.roleOutcome.kind === "accepted") {
             return auditSubmittedRole(result, env, io);
         }
-        for (const value of held)
-            io.stdout(value);
+        await presentOriginalVolume(held, result.terminal, io, result.admitted?.runDirectory);
         return result;
     };
     let binding;
@@ -825,7 +806,7 @@ async function queueConclusionFromChild(child, env, io) {
     if (!GATE_CHILD_ROLES.has(child.role))
         return undefined;
     if (child.role === "countersign") {
-        const terminal = await trySettlePublicSeat(child, env.principalAuthority, await readCurrentCourt(child.runDirectory));
+        const terminal = await trySettlePublicSeat(child, env.principalAuthority, { ...await readCurrentCourt(child.runDirectory), ...packageFaultScope(child, env, io) });
         const status = latestQueueStatus(terminal);
         if (terminal !== undefined && typeof status === "string" && REVIEW_QUEUE_STATUSES.has(status)) {
             return { admitted: child, terminal, status };
@@ -838,7 +819,7 @@ async function queueConclusionFromChild(child, env, io) {
     // failure recovery, and other reask loops stay separate.
     let budgetEnv = { ...env, unreadableReasksSpent: 0 };
     for (;;) {
-        const terminal = await trySettlePublicSeat(current, env.principalAuthority, await readCurrentCourt(current.runDirectory));
+        const terminal = await trySettlePublicSeat(current, env.principalAuthority, { ...await readCurrentCourt(current.runDirectory), ...packageFaultScope(current, env, io) });
         const status = latestQueueStatus(terminal);
         if (terminal !== undefined && typeof status === "string" && REVIEW_QUEUE_STATUSES.has(status)) {
             return { admitted: current, terminal, status };
@@ -878,7 +859,7 @@ export async function continueParentAfterChild(parentRunId, child, env, io) {
             const parentTerminal = await trySettlePublicSeat(admitted, env.principalAuthority, undefined);
             if (parentTerminal?.roleOutcome.kind === "accepted"
                 || parentTerminal?.roleOutcome.kind === "audit_escalation") {
-                const terminal = presentUnsettledAudit(parentTerminal, stopped.terminal, io);
+                const terminal = await presentUnsettledAudit(parentTerminal, stopped.terminal, io, admitted.runDirectory);
                 return { exitCode: 0, admitted, terminal };
             }
         }
@@ -889,14 +870,14 @@ export async function continueParentAfterChild(parentRunId, child, env, io) {
     }
     if (resolved !== undefined && (resolved.status === "continue" || resolved.status === "converged")) {
         if (AUDITED_ROLES.has(admitted.role) && resolved.status === "converged") {
-            const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, undefined);
+            const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, packageFaultScope(admitted, env, io));
             if (terminal?.roleOutcome.kind !== "accepted")
                 throw new Error("pending submission is not recorded");
             return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted, latestQueuePayload(resolved.terminal));
         }
         return runPublicInstructionSeatResume({
             runId: parentRunId,
-            message: readableGateItem(latestQueuePayload(resolved.terminal)),
+            summons: { instruction: readableGateItem(latestQueuePayload(resolved.terminal)) },
         }, { ...env, unreadableReasksSpent: 0 }, io);
     }
     const result = await dispatchAdmitted(admitted, env, { ...io, omitFailureStderrDiagnostic: true });
@@ -955,10 +936,10 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         const next = withUnreadableReask(env);
         if (next === undefined) {
             const terminal = withUnsettledDirection(turn.terminal);
-            io.stdout(formatTerminalResult(terminal));
+            await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
             return { ...turn, terminal };
         }
-        return runPublicInstructionSeatResume({ runId: admitted.runId, message: SECRETARIAT_STATUS_REASK }, next, io);
+        return runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction: SECRETARIAT_STATUS_REASK } }, next, io);
     }
     if (admitted.role === "countersign" && (typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status))) {
         if (gateOwnsStatusReask)
@@ -966,10 +947,10 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         const next = withUnreadableReask(env);
         if (next === undefined) {
             const terminal = withUnsettledDirection(turn.terminal);
-            io.stdout(formatTerminalResult(terminal));
+            await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
             return { ...turn, terminal };
         }
-        return runPublicInstructionSeatResume({ runId: admitted.runId, message: officerConclusionReask(status) }, next, io);
+        return runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction: officerConclusionReask(status) } }, next, io);
     }
     // Self-escalation is a valid open routing state for these seats only.
     // Doctor's declared domain is completed|refused — an open "escalate" must
@@ -981,7 +962,7 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         || ((admitted.role === "fixer" || admitted.role === "coder")
             && (typeof status !== "string" || !WORKER_DONE_STATUSES.has(status)));
     if (skipAudit) {
-        io.stdout(formatTerminalResult(turn.terminal));
+        await presentTerminal(turn.terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
         return turn;
     }
     const rows = await readRecordedSubmissionRows(admitted.projectRoot, admitted.runId, env.home);
@@ -990,7 +971,9 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
     if (toolCallId === undefined)
         throw new Error("accepted submission has no tool call identity");
     const sessionFile = env.principalAuthority.decode(admitted.principal).sessionFile;
-    const entries = admitted.role === "doctor" ? await readBoundSessionEntries(sessionFile) : [];
+    const entries = admitted.role === "doctor"
+        ? await readBoundSessionEntries(sessionFile)
+        : [];
     const context = {
         cwd: admitted.projectRoot,
         mode: "print",
@@ -1047,7 +1030,7 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
             });
             if (decision.status === "continue") {
                 return runPublicInstructionSeatResume({
-                    runId: admitted.runId, message: readableGateItem(decision.receipt ?? decision.violations),
+                    runId: admitted.runId, summons: { instruction: readableGateItem(decision.receipt ?? decision.violations) },
                 }, { ...env, unreadableReasksSpent: 0 }, io);
             }
             if (decision.status === "received") {
@@ -1056,12 +1039,12 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
                 }
                 if (turn.terminal === undefined)
                     throw new Error("doctor submission has no terminal");
-                const terminal = presentUnsettledAudit(turn.terminal, lastSummon.terminal, io);
+                const terminal = await presentUnsettledAudit(turn.terminal, lastSummon.terminal, io, admitted.runDirectory);
                 return { exitCode: 0, admitted, terminal };
             }
             if (decision.status !== "converged") {
                 if (lastSummon?.terminal !== undefined) {
-                    io.stdout(formatTerminalResult(lastSummon.terminal));
+                    await presentTerminal(lastSummon.terminal, { ...io, omitFailureStderrDiagnostic: true }, lastSummon.admitted?.runDirectory ?? admitted.runDirectory);
                     return { exitCode: lastSummon.exitCode,
                         ...(lastSummon.admitted === undefined ? {} : { admitted: lastSummon.admitted }),
                         terminal: lastSummon.terminal };
@@ -1133,7 +1116,7 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
                 throw new Error("unreadable audit has no terminal result");
             if (turn.terminal === undefined)
                 throw new Error("audited submission has no terminal");
-            const terminal = presentUnsettledAudit(turn.terminal, officerTerminal, io);
+            const terminal = await presentUnsettledAudit(turn.terminal, officerTerminal, io, admitted.runDirectory);
             return { exitCode: 0, admitted, terminal };
         }
         if (chain.status === "escalate") {
@@ -1144,16 +1127,16 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
             if (escalatedRunId === undefined)
                 throw new Error("escalated audit has no resumable run identity");
             const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority);
-            const terminal = await trySettlePublicSeat(officer.admitted, env.principalAuthority, await readCurrentCourt(officer.admitted.runDirectory));
+            const terminal = await trySettlePublicSeat(officer.admitted, env.principalAuthority, { ...await readCurrentCourt(officer.admitted.runDirectory), ...packageFaultScope(officer.admitted, env, io) });
             if (terminal === undefined)
                 throw new Error("escalated audit has no terminal result");
-            io.stdout(formatTerminalResult(terminal));
+            await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, officer.admitted.runDirectory);
             return { exitCode: 0, admitted: officer.admitted, terminal };
         }
         if (chain.status === "continue") {
             return runPublicInstructionSeatResume({
                 runId: admitted.runId,
-                message: readableGateItem(chain.passes.at(-1)?.receipt),
+                summons: { instruction: readableGateItem(chain.passes.at(-1)?.receipt) },
             }, { ...env, unreadableReasksSpent: 0 }, io);
         }
         if (admitted.role === "secretariat") {
@@ -1172,8 +1155,8 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
     // settle would republish the same attempt.
     if (turn.terminal === undefined)
         throw new Error(`audited ${admitted.role} submission did not settle`);
-    const terminal = await attachPostAuditProjection(admitted, env.principalAuthority, turn.terminal);
+    const terminal = await attachPostAuditProjection(admitted, env.principalAuthority, turn.terminal, packageFaultScope(admitted, env, io));
     turn = { ...turn, terminal };
-    io.stdout(formatTerminalResult(terminal));
+    await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
     return turn;
 }