@akagilnc/pi-workflow-roles 0.1.4021 → 0.1.4035

package/dist/public-cli/settlement.js

@@ -54,10 +54,14 @@ function ledgerReadScope(admitted, scope) {
 }
 function roleOutcomeFromRows(role, rows) {
     const mine = rows.filter((row) => row.role === role);
-    if (mine.length === 0)
+    // Terminal acceptance kind still only follows sealed / audit-escalation (#881):
+    // correctable-rejection / infrastructure / candidate stay payloads, not acceptance.
+    const terminal = mine.filter((row) => row.kind === "accepted" || row.kind === "audit-escalation");
+    if (terminal.length === 0)
         return undefined;
+    // Role-result block is the full recorded sequence for this seat, not a sole pick.
     const payloads = mine.map((row) => row.accepted);
-    if (mine.some((row) => row.kind === "audit-escalation")) {
+    if (terminal.some((row) => row.kind === "audit-escalation")) {
         return { kind: "audit_escalation", role, status: "audit_escalation", payloads };
     }
     return { kind: "accepted", role, payloads };
@@ -89,11 +93,11 @@ export function withSubmissions(terminal, submissions) {
     if (submissions.length === 0)
         return terminal;
     const roleOutcome = terminal.roleOutcome;
-    const withPayloads = roleOutcome.kind === "accepted" || roleOutcome.kind === "audit_escalation"
-        ? { ...roleOutcome, payloads: (roleOutcome.payloads ?? []).length > 0 ? roleOutcome.payloads : submissions }
-        : roleOutcome.kind === "failure"
-            ? { ...roleOutcome, payloads: roleOutcome.payloads ?? submissions }
-            : roleOutcome;
+    // Full ledger sequence always wins the role-result block (#881): do not keep a
+    // narrower pre-filtered payloads array when attach brings the complete set.
+    const withPayloads = roleOutcome.kind === "accepted" || roleOutcome.kind === "audit_escalation" || roleOutcome.kind === "failure"
+        ? { ...roleOutcome, payloads: submissions }
+        : roleOutcome;
     return { ...terminal, roleOutcome: withPayloads, submissions };
 }
 /** Attach full ledger submissions onto any settled terminal (#836). */
@@ -133,7 +137,7 @@ async function closedLedgerOutcome(admitted, role, scope) {
 function coordinatesFromAdmitted(authority, admitted) {
     return authority.decode(admitted.principal);
 }
-import { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, lastRolePayloadRecord, recommendationNavigatorFact, } from "./terminal.js";
+import { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, recommendationNavigatorFact, } from "./terminal.js";
 export { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, };
 /**
  * Host stderr as recorded — full bytes, no flood filter, no char clip (#836).
@@ -223,8 +227,7 @@ function isTypedActivationError(error) {
         cause === "activation" ||
         cause === "session" ||
         cause === "output" ||
-        cause === "timeout" ||
-        cause === "unrecognized");
+        cause === "timeout");
 }
 /** Flatten nested AggregateError leaves; non-aggregate values stay as one fact. */
 function flattenThrownFailureLeaves(error) {
@@ -250,21 +253,20 @@ export function projectThrownFailureLeaf(error) {
         }
         return {
             cause: error.knownCause,
-            diagnostic: error.message || error.name || "unrecognized exception",
+            diagnostic: error.message || error.name || "exception",
             identity,
             ...(error.details === undefined ? {} : { details: error.details }),
         };
     }
     if (error instanceof Error) {
         const identity = thrownIdentity(error);
+        // No typed confirmation → keep original diagnostic/identity; do not mint a class (#881).
         return {
-            cause: "unrecognized",
-            diagnostic: error.message || error.name || "unrecognized exception",
+            diagnostic: error.message || error.name || "exception",
             identity,
         };
     }
     return {
-        cause: "unrecognized",
         diagnostic: String(error),
     };
 }
@@ -294,7 +296,7 @@ function classifyThrownFailure(error) {
         ...leaves.slice(1).map((leaf) => {
             const secondary = projectThrownFailureLeaf(leaf);
             return {
-                cause: secondary.cause,
+                ...(secondary.cause === undefined ? {} : { cause: secondary.cause }),
                 diagnostic: secondary.diagnostic,
                 ...(secondary.identity === undefined ? {} : { identity: secondary.identity }),
                 ...(secondary.details === undefined ? {} : { details: secondary.details }),
@@ -302,7 +304,7 @@ function classifyThrownFailure(error) {
         }),
     ];
     return {
-        cause: primary.cause,
+        ...(primary.cause === undefined ? {} : { cause: primary.cause }),
         diagnostic: primary.diagnostic,
         ...(primary.identity === undefined ? {} : { identity: primary.identity }),
         details: {
@@ -325,7 +327,7 @@ function withKnownDetails(failure, knownDetails) {
     };
 }
 /**
- * Classify a controlled post-admission failure without washing unrecognized identities.
+ * Classify a controlled post-admission failure without washing original identities.
  * Cause classes are closed; diagnostic text retains the original identity when known.
  *
  * Order: thrown → knownCause → timeout → activation (nonzero) → session → output.
@@ -365,6 +367,30 @@ export function classifyPostAdmissionFailure(input) {
                 : { identity: input.knownIdentity }),
         };
     }
+    // #881: original failure testimony without a typed class — keep diagnostic/identity;
+    // do not fall through to activation/output wash that would mint a substitute class.
+    // Bare knownDetails alone is secondary evidence for later branches (withKnownDetails),
+    // not a stand-in primary failure record.
+    if ((input.knownDiagnostic !== undefined && input.knownDiagnostic.trim() !== "") ||
+        input.knownIdentity !== undefined) {
+        const diagnostic = input.knownDiagnostic !== undefined && input.knownDiagnostic.trim() !== ""
+            ? input.knownDiagnostic
+            : conciseChildDiagnostic(input.stderr, "role run failed");
+        const { timedOut: _knownTimedOut, ...knownDetails } = input.knownDetails ?? {};
+        const remoteCode = knownDetails.code;
+        return withKnownDetails({
+            diagnostic,
+            details: {
+                ...knownDetails,
+                ...(remoteCode === undefined ? {} : { code: remoteCode }),
+                exitCode: input.code,
+                ...(input.timedOut ? { timedOut: true } : {}),
+            },
+            ...(input.knownIdentity === undefined
+                ? {}
+                : { identity: input.knownIdentity }),
+        }, undefined);
+    }
     if (input.timedOut) {
         return withKnownDetails({
             cause: "timeout",
@@ -405,7 +431,7 @@ export function explicitInternalKnownFailureClassificationInput(failure) {
     if (failure === undefined)
         return {};
     return {
-        knownCause: failure.cause,
+        ...(failure.cause === undefined ? {} : { knownCause: failure.cause }),
         ...(failure.identity === undefined ? {} : { knownIdentity: failure.identity }),
         ...(failure.diagnostic === undefined ? {} : { knownDiagnostic: failure.diagnostic }),
         ...(failure.details === undefined ? {} : { knownDetails: failure.details }),
@@ -755,11 +781,21 @@ function complianceFailureFromAuditorVolumes(volumes) {
                 continue;
             const parent = isRecord(entry.data.parent) ? entry.data.parent : undefined;
             const failure = isRecord(entry.data.failure) ? entry.data.failure : undefined;
-            if (parent?.sessionId !== parentId || parent.sessionFile !== sessionFile || parent.attemptEntryId !== attemptEntryId || (failure?.cause !== "provider" && failure?.cause !== "unrecognized"))
+            if (parent?.sessionId !== parentId || parent.sessionFile !== sessionFile || parent.attemptEntryId !== attemptEntryId)
+                continue;
+            // #881: keep the recorded failure as written — typed cause when present, else raw diagnostic only.
+            if (failure === undefined)
                 continue;
             const identity = isRecord(failure.identity) ? failure.identity : undefined;
+            const typedCause = failure.cause === "provider" ||
+                failure.cause === "activation" ||
+                failure.cause === "session" ||
+                failure.cause === "output" ||
+                failure.cause === "timeout"
+                ? failure.cause
+                : undefined;
             return {
-                cause: failure.cause === "provider" ? "provider" : "unrecognized",
+                ...(typedCause === undefined ? {} : { cause: typedCause }),
                 ...(identity === undefined ? {} : { identity: {
                         ...(typeof identity.name === "string" ? { name: identity.name } : {}),
                         ...(typeof identity.code === "string" || typeof identity.code === "number" ? { code: identity.code } : {}),
@@ -1683,9 +1719,6 @@ export async function publishCoderArtifacts(admitted, roleOutcome, coordinates,
         runId: admitted.runId,
         phase: admitted.phase,
         outcome: roleOutcome,
-        ...(options.coderOutput === undefined
-            ? {}
-            : { receipt: options.coderOutput }),
     }, null, 2)}\n`, "utf8");
     await writeFile(evidencePath, `${JSON.stringify({
         runId: admitted.runId,
@@ -1789,14 +1822,10 @@ async function settleLawfulCoderTerminalResult(admitted, authority, options = {}
     if (ledgerOutcome === undefined)
         return undefined;
     const roleOutcome = ledgerOutcome;
-    const output = ledgerOutcome.kind === "accepted"
-        ? lastRolePayloadRecord(ledgerOutcome.payloads ?? [])
-        : undefined;
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const entries = await readLawfulSettlementEntries(coordinates.sessionFile) ?? [];
     const navigator = extractNavigatorFact(entries);
     const artifacts = await publishCoderArtifacts(admitted, roleOutcome, coordinates, {
-        ...(output === undefined ? {} : { coderOutput: output }),
         ...(options.methodProvenance === undefined
             ? {}
             : { methodProvenance: options.methodProvenance }),
@@ -1873,9 +1902,6 @@ export async function publishFixerArtifacts(admitted, roleOutcome, coordinates,
         runId: admitted.runId,
         phase: admitted.phase,
         outcome: roleOutcome,
-        ...(options.fixerOutput === undefined
-            ? {}
-            : { receipt: options.fixerOutput }),
     }, null, 2)}\n`, "utf8");
     await writeFile(evidencePath, `${JSON.stringify({
         runId: admitted.runId,
@@ -1910,9 +1936,6 @@ async function settleLawfulFixerTerminalResult(admitted, authority, options, sco
     if (ledgerOutcome === undefined)
         return undefined;
     const roleOutcome = ledgerOutcome;
-    const output = ledgerOutcome.kind === "accepted"
-        ? lastRolePayloadRecord(ledgerOutcome.payloads ?? [])
-        : undefined;
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const { sessionDirectory, sessionFile } = coordinates;
     const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
@@ -1924,7 +1947,6 @@ async function settleLawfulFixerTerminalResult(admitted, authority, options, sco
         ],
     });
     const artifacts = await publishFixerArtifacts(admitted, roleOutcome, coordinates, {
-        ...(output === undefined ? {} : { fixerOutput: output }),
         methodProvenance: options.methodProvenance,
         methodInvocations,
     });
@@ -1943,7 +1965,7 @@ export async function settleFixerTerminalResult(admitted, authority, options, sc
     }
     return settled;
 }
-export async function publishCollectorArtifacts(admitted, roleOutcome, coordinates, options = {}) {
+export async function publishCollectorArtifacts(admitted, roleOutcome, coordinates) {
     await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
     const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
     const reportPath = join(artifactsDir, "report.json");
@@ -1952,9 +1974,6 @@ export async function publishCollectorArtifacts(admitted, roleOutcome, coordinat
         role: "collector",
         runId: admitted.runId,
         outcome: roleOutcome,
-        ...(options.collectorReceipt === undefined
-            ? {}
-            : { receipt: options.collectorReceipt }),
     }, null, 2)}\n`, "utf8");
     await writeFile(evidencePath, `${JSON.stringify({
         runId: admitted.runId,
@@ -2004,10 +2023,9 @@ async function settleLawfulCollectorTerminalResult(admitted, authority, scope) {
         }
         return undefined;
     }
-    const receipt = (lastRolePayloadRecord(roleOutcome.payloads ?? []) ?? {});
     const accepted = roleOutcome;
     const navigator = extractNavigatorFact(entries);
-    const artifacts = await publishCollectorArtifacts(admitted, accepted, coordinates, { collectorReceipt: receipt });
+    const artifacts = await publishCollectorArtifacts(admitted, accepted, coordinates);
     return attachRecordedSubmissions(admitted, await withOptionalGateProjection({
         roleOutcome: accepted,
         navigator,
@@ -2069,10 +2087,6 @@ export async function publishDoctorArtifacts(admitted, roleOutcome, coordinates,
         role: "doctor",
         runId: admitted.runId,
         outcome: roleOutcome,
-        ...(options.doctorOutput === undefined
-            ? {}
-            : { receipt: options.doctorOutput }),
-        // Independent machine fields beside the receipt — not merged into it.
         ...(options.cost === undefined ? {} : { cost: options.cost }),
         ...(options.auditNoReceipt === undefined ? {} : { auditNoReceipt: options.auditNoReceipt }),
     }, null, 2)}\n`, "utf8");
@@ -2113,13 +2127,11 @@ async function settleLawfulDoctorTerminalResult(admitted, authority, scope) {
             runId: admitted.runId,
         }, sessionDirectory);
     }
-    const output = (lastRolePayloadRecord(sealed.payloads ?? []) ?? {});
     const roleOutcome = sealed;
     const navigator = extractNavigatorFact(entries);
     const cost = extractDoctorCandidateCostFact(entries);
     const auditNoReceipt = extractDoctorCandidateAuditNoReceiptFact(entries);
     const artifacts = await publishDoctorArtifacts(admitted, roleOutcome, coordinates, {
-        doctorOutput: output,
         ...(cost === undefined ? {} : { cost }),
         ...(auditNoReceipt === undefined ? {} : { auditNoReceipt }),
     });
@@ -2346,9 +2358,6 @@ export async function publishReviewerArtifacts(admitted, roleOutcome, coordinate
         role: "reviewer",
         runId: admitted.runId,
         outcome: roleOutcome,
-        ...(options.reviewerReceipt === undefined
-            ? {}
-            : { receipt: options.reviewerReceipt }),
     }, null, 2)}\n`, "utf8");
     await writeFile(evidencePath, `${JSON.stringify({
         runId: admitted.runId,
@@ -2384,7 +2393,6 @@ async function settleLawfulReviewerTerminalResult(admitted, authority, options,
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const { sessionDirectory, sessionFile } = coordinates;
     const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-    const receipt = lastRolePayloadRecord(sealed.payloads ?? []);
     const roleOutcome = sealed;
     const navigator = extractNavigatorFact(entries);
     const methodInvocations = extractReviewerMethodInvocations(entries, {
@@ -2394,7 +2402,6 @@ async function settleLawfulReviewerTerminalResult(admitted, authority, options,
         ],
     });
     const artifacts = await publishReviewerArtifacts(admitted, roleOutcome, coordinates, {
-        ...(receipt === undefined ? {} : { reviewerReceipt: receipt }),
         methodProvenance: options.methodProvenance,
         methodInvocations,
     });
@@ -2455,9 +2462,6 @@ export async function publishMergerArtifacts(admitted, roleOutcome, coordinates,
         role: "merger",
         runId: admitted.runId,
         outcome: roleOutcome,
-        ...(options.mergerOutput === undefined
-            ? {}
-            : { receipt: options.mergerOutput }),
     }, null, 2)}\n`, "utf8");
     await writeFile(evidencePath, `${JSON.stringify({
         runId: admitted.runId,
@@ -2513,7 +2517,6 @@ async function settleLawfulMergerTerminalResult(admitted, authority, options, sc
         allowedLocations: [options.methodSkillPath, options.methodSkillConfiguredPath],
     });
     const artifacts = await publishMergerArtifacts(admitted, accepted, coordinates, {
-        mergerOutput: (lastRolePayloadRecord(accepted.payloads ?? []) ?? {}),
         methodProvenance: options.methodProvenance,
         methodInvocations,
     });
@@ -2666,7 +2669,7 @@ export async function publishFailureArtifacts(admitted, failure, authority) {
         kind: "error",
         role: admitted.role,
         runId: admitted.runId,
-        cause: failure.cause,
+        ...(failure.cause === undefined ? {} : { cause: failure.cause }),
         diagnostic: failure.diagnostic,
         ...(failure.identity === undefined ? {} : { identity: failure.identity }),
         ...(failure.details === undefined ? {} : { details: failure.details }),
@@ -2683,7 +2686,7 @@ export async function publishFailureArtifacts(admitted, failure, authority) {
             sha256: a.sha256,
             byteLength: a.byteLength,
         })),
-        failureCause: failure.cause,
+        ...(failure.cause === undefined ? {} : { failureCause: failure.cause }),
     };
     const evidenceWrite = await writeFailureJsonRetainingCause(evidenceCandidates, uniqueFallbackDirs, "evidence", evidencePayload, 
     // Evidence records the same publication collisions observed placing the error body.
@@ -2750,7 +2753,7 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
     // Private durable artifacts retain the original diagnostic identity (including run ID).
     const artifacts = await publishFailureArtifacts(admitted, failure, authority);
     const decisiveFacts = {
-        cause: failure.cause,
+        ...(failure.cause === undefined ? {} : { cause: failure.cause }),
         diagnostic: failure.diagnostic,
     };
     if (failure.identity?.name !== undefined) {
@@ -2770,7 +2773,7 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
         const roleOutcome = {
             kind: "failure",
             role: admitted.role,
-            cause: failure.cause,
+            ...(failure.cause === undefined ? {} : { cause: failure.cause }),
             diagnostic: failure.diagnostic,
             decisiveFacts,
         };
@@ -2784,7 +2787,7 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
     const roleOutcome = {
         kind: "failure",
         role: admitted.role,
-        cause: failure.cause,
+        ...(failure.cause === undefined ? {} : { cause: failure.cause }),
         diagnostic: failure.diagnostic,
         decisiveFacts,
     };
@@ -2811,7 +2814,7 @@ export function presentFailureTerminal(terminal, io) {
     io.stdout(formatTerminalResult(terminal));
     if (terminal.roleOutcome.kind === "failure") {
         io.stderr(formatFailureStderrDiagnostic({
-            cause: terminal.roleOutcome.cause,
+            ...(terminal.roleOutcome.cause === undefined ? {} : { cause: terminal.roleOutcome.cause }),
             diagnostic: terminal.roleOutcome.diagnostic,
         }));
         return;

package/dist/public-cli/terminal.js

@@ -33,16 +33,6 @@ export function roleResultPayloads(outcome) {
         return outcome.payloads ?? [];
     return [];
 }
-/** Last object payload the role actually wrote. No field remapping. */
-export function lastRolePayloadRecord(payloads) {
-    for (let index = payloads.length - 1; index >= 0; index -= 1) {
-        const payload = payloads[index];
-        if (typeof payload === "object" && payload !== null && !Array.isArray(payload)) {
-            return payload;
-        }
-    }
-    return undefined;
-}
 /**
  * Build a recommendation navigator fact. Model command is kept when present;
  * registry render is fallback only. Unknown seats stay recommendations (#836 B4.1).
@@ -71,7 +61,7 @@ export function formatTerminalResult(result) {
     const lines = [];
     lines.push("role\toutcome\tstatus");
     const outcomeStatus = result.roleOutcome.kind === "failure"
-        ? result.roleOutcome.cause
+        ? result.roleOutcome.cause ?? ""
         : result.roleOutcome.kind === "accepted"
             ? "accepted"
             : result.roleOutcome.status;

package/dist/submission-ledger.js

@@ -110,8 +110,45 @@ function recordedRole(payload) {
         return payload.projection.role;
     return undefined;
 }
+/** Prefer a more complete row for the same tool call without inventing a sole winner across calls. */
+function rowRank(kind) {
+    switch (kind) {
+        case "accepted":
+            return 4;
+        case "audit-escalation":
+            return 3;
+        case "correctable-rejection":
+        case "infrastructure":
+            return 2;
+        case "candidate":
+            return 1;
+    }
+}
+/**
+ * Same-call identity for reader pairing only (#881 / #836).
+ * attemptId is already on the record (subject/payload); bare toolCallId alone
+ * collapses distinct court attempts that reused a host call id.
+ */
+function submissionCallKey(attemptId, toolCallId) {
+    return `${attemptId ?? ""}\0${toolCallId}`;
+}
+function rowFromPayload(kind, payload, accepted, roleFallback) {
+    const role = recordedRole(payload) ?? roleFallback;
+    return {
+        ...(role === undefined ? {} : { role }),
+        kind,
+        accepted,
+        ...(typeof payload.toolCallId === "string" && payload.toolCallId.length > 0
+            ? { toolCallId: payload.toolCallId }
+            : {}),
+    };
+}
 /**
- * All recorded role submissions in ledger order (#836 multi-submit).
+ * All recorded role submissions in ledger order (#836 multi-submit / #881).
+ * Projects every original payload — sealed, audit-escalation, correctable-rejection,
+ * infrastructure, and bare candidate — without outcome-class filtering.
+ * Same call (candidate + outcome both carrying params) appears once — keyed by
+ * recorded attemptId + toolCallId so distinct court attempts stay distinct (#881).
  * `accepted` is the original payload; never rebuilt from a status/facts envelope.
  */
 export async function readRecordedSubmissionRows(cwd, runId, homeOrScope) {
@@ -119,27 +156,85 @@ export async function readRecordedSubmissionRows(cwd, runId, homeOrScope) {
     const { owned } = await readOwnedSubmissionRecords(cwd, runId, scope.home);
     const scoped = recordsForAttempt(owned, scope.attemptId);
     const out = [];
+    const indexByCall = new Map();
+    // Recover seat identity for historical non-sealed rows that omitted role (#881).
+    const roleByCall = new Map();
     for (const record of scoped) {
+        const payload = record.payload;
+        if (typeof payload?.toolCallId !== "string" || payload.toolCallId.length === 0)
+            continue;
+        const role = recordedRole(payload);
+        if (role !== undefined) {
+            roleByCall.set(submissionCallKey(recordAttemptId(record), payload.toolCallId), role);
+        }
+    }
+    const take = (row, callKey) => {
+        const toolCallId = row.toolCallId;
+        if (toolCallId !== undefined && callKey !== undefined) {
+            const existingIndex = indexByCall.get(callKey);
+            if (existingIndex !== undefined) {
+                const existing = out[existingIndex];
+                if (rowRank(row.kind) >= rowRank(existing.kind)) {
+                    out[existingIndex] = {
+                        ...row,
+                        toolCallId,
+                        // Keep a previously recovered role when the upgraded row still omits it.
+                        ...(row.role === undefined && existing.role !== undefined ? { role: existing.role } : {}),
+                    };
+                }
+                else if (existing.role === undefined && row.role !== undefined) {
+                    out[existingIndex] = { ...existing, role: row.role };
+                }
+                return;
+            }
+            indexByCall.set(callKey, out.length);
+        }
+        out.push(row);
+    };
+    for (const record of scoped) {
+        const attemptId = recordAttemptId(record);
+        if (record.kind === "candidate") {
+            const payload = record.payload;
+            if (payload?.type !== "candidate" || payload.params === undefined)
+                continue;
+            const callKey = typeof payload.toolCallId === "string"
+                ? submissionCallKey(attemptId, payload.toolCallId)
+                : undefined;
+            const fallback = callKey !== undefined ? roleByCall.get(callKey) : undefined;
+            take(rowFromPayload("candidate", payload, payload.params, fallback), callKey);
+            continue;
+        }
         if (record.kind === "sealed") {
             const payload = record.payload;
             if (payload?.type !== "sealed" || payload.accepted === undefined)
                 continue;
-            const role = recordedRole(payload);
-            if (role === undefined)
-                continue;
-            out.push({ role, kind: "accepted", accepted: payload.accepted });
+            const callKey = typeof payload.toolCallId === "string"
+                ? submissionCallKey(attemptId, payload.toolCallId)
+                : undefined;
+            const fallback = callKey !== undefined ? roleByCall.get(callKey) : undefined;
+            take(rowFromPayload("accepted", payload, payload.accepted, fallback), callKey);
             continue;
         }
         if (record.kind !== "outcome")
             continue;
         const payload = record.payload;
-        if (payload?.type !== "outcome" || payload.outcome !== "audit-escalation" || payload.accepted === undefined) {
+        if (payload?.type !== "outcome" || payload.accepted === undefined)
             continue;
-        }
-        const role = recordedRole(payload);
-        if (role === undefined)
+        const outcome = payload.outcome;
+        const kind = outcome === "audit-escalation"
+            ? "audit-escalation"
+            : outcome === "correctable-rejection"
+                ? "correctable-rejection"
+                : outcome === "infrastructure"
+                    ? "infrastructure"
+                    : undefined;
+        if (kind === undefined)
             continue;
-        out.push({ role, kind: "audit-escalation", accepted: payload.accepted });
+        const callKey = typeof payload.toolCallId === "string"
+            ? submissionCallKey(attemptId, payload.toolCallId)
+            : undefined;
+        const fallback = callKey !== undefined ? roleByCall.get(callKey) : undefined;
+        take(rowFromPayload(kind, payload, payload.accepted, fallback), callKey);
     }
     return out;
 }
@@ -150,7 +245,7 @@ export async function readRecordedSubmissionRows(cwd, runId, homeOrScope) {
 export async function readRecordedSubmissions(cwd, runId, homeOrScope) {
     return (await readRecordedSubmissionRows(cwd, runId, homeOrScope)).map((row) => row.accepted);
 }
-/** True when the run has at least one recorded accepted or audit-escalation payload. */
+/** True when the run has at least one recorded original payload (any outcome class). */
 export async function hasRecordedSubmission(cwd, runId, homeOrScope) {
     return (await readRecordedSubmissionRows(cwd, runId, homeOrScope)).length > 0;
 }
@@ -254,6 +349,7 @@ export function createSubmissionLedgerHost(host, outputTools, failInfrastructure
                         toolCallId,
                         toolName: tool.name,
                         sequence: ++state.sequence,
+                        role,
                         params,
                     });
                     let result;
@@ -274,6 +370,7 @@ export function createSubmissionLedgerHost(host, outputTools, failInfrastructure
                                 outcome: "correctable-rejection",
                                 code: "typed-bounce",
                                 diagnostic: error instanceof Error ? error.message : String(error),
+                                role,
                                 accepted: params,
                             });
                             throw error;
@@ -285,6 +382,7 @@ export function createSubmissionLedgerHost(host, outputTools, failInfrastructure
                                 toolCallId,
                                 outcome: "infrastructure",
                                 diagnostic: error instanceof Error ? error.message : String(error),
+                                role,
                                 accepted: params,
                             });
                             throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.4021",
+  "version": "0.1.4035",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/host-contracts.ts

@@ -15,18 +15,22 @@ export type HostToolResult<T = unknown> = {
 /** Opaque host-owned identity persisted with a Role run. */
 export type DurablePrincipal = object & { readonly __durablePrincipal?: never };
 
-/** Controlled post-admission failure classes (ADR 0052 / #107). Owner = host contract. */
+/**
+ * Controlled post-admission failure classes (ADR 0052 / #107). Owner = host contract.
+ * Closed set of typed facts only — never a fabricated "could not classify" label (#881).
+ * When no typed confirmation exists, omit cause and keep the original diagnostic / error pointer.
+ */
 export type ControlledFailureCause =
   | "activation"
   | "provider"
   | "session"
   | "output"
-  | "timeout"
-  | "unrecognized";
+  | "timeout";
 
 /** Production-owned typed failure carried on a resolved turn result. */
 export type RoleTurnKnownFailure = {
-  readonly cause: ControlledFailureCause;
+  /** Present only when a typed fact confirms the class; omitted when unknown (#881). */
+  readonly cause?: ControlledFailureCause;
   readonly identity?: {
     readonly name?: string;
     readonly code?: string | number;

package/src/navigator-attendance.ts

@@ -25,6 +25,7 @@ import {
   navigatorProviderFailure,
   navigatorProviderFailureFromDiagnostics,
   navigatorProviderFailureFromError,
+  navigatorProviderFailureFromPublicTerminal,
   navigatorProviderFailureFromStatus,
   navigatorUnavailableError,
   parseNavigatorModelSetting,
@@ -46,6 +47,7 @@ export {
   navigatorProviderFailure,
   navigatorProviderFailureFromDiagnostics,
   navigatorProviderFailureFromError,
+  navigatorProviderFailureFromPublicTerminal,
   navigatorProviderFailureFromStatus,
   navigatorUnavailableError,
   parseNavigatorModelSetting,