@akagilnc/pi-workflow-roles 0.1.4673 → 0.1.4698

package/dist/public-cli/settlement.js

@@ -4,7 +4,7 @@
  * Controlled failures and audit human decisions settle here without washing causes.
  */
 import { randomUUID } from "node:crypto";
-import { appendFile, lstat, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { appendFile, lstat, readFile, readdir, rm, unlink, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { readAnalystGateCyclesFromAuditorRoles, } from "../analyst-gate-cycles-read.js";
 import { readSitianRecords, resolveSitianRecordPath, sitianReport } from "../sitian-facade.js";
@@ -41,6 +41,7 @@ import { observePackagedMethodSkillInvocation, } from "../package-resources/meth
 import { classifyPackagedRoleTerminalResult, findLatestDurablePackagedRoleTerminal, hasNavigatorInfrastructureFailureBase, isAcceptedPackagedRoleTerminalResult, isReceiptSettlementBindingClear, NAVIGATOR_INVOCATION_ENTRY, parseInvocationMarkerIdentity, } from "../navigator-invocation-identity.js";
 import { NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_TURN_LIMIT, noReceiptLifecycleFacts, parseNoReceiptLifecycleFacts, } from "../receipt-delivery-policy.js";
 import { roleRunArtifactsDirectory } from "../role-run-placement.js";
+import { listSeamOwnedUniqueErrorFacePaths, RUN_TERMINAL_ARTIFACT_FILES, RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS, } from "../run-terminal-artifacts.js";
 import { ensureRunArtifactsDir, homeFromRunDirectory, } from "./invocation.js";
 /** Ledger reads use the run's machine home — not ambient process HOME (child write vs parent settle). */
 function sealedLedgerHome(admitted) {
@@ -107,13 +108,20 @@ export function withSubmissions(terminal, submissions) {
     if (submissions.length === 0)
         return terminal;
     const roleOutcome = terminal.roleOutcome;
-    // #879 keeps an already scoped this-court result; #881 full run history is
-    // presented independently on terminal.submissions. Only fill a missing result payload.
+    // #881 / #836: full run history always lands on terminal.submissions.
+    // #879: accepted/audit_escalation may still fill a missing this-court
+    // payloads face from that history. #953: failure must not — prior receipts
+    // stay on the historical carrier only, never as the current failure's
+    // ordinary payloads/receipt face.
+    if (roleOutcome.kind === "failure") {
+        return { ...terminal, submissions };
+    }
     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;
+        ? {
+            ...roleOutcome,
+            payloads: coalesceSubmissionRows(roleOutcome.payloads, submissions),
+        }
+        : roleOutcome;
     return { ...terminal, roleOutcome: withPayloads, submissions };
 }
 /** Attach full ledger submissions onto any settled terminal (#836). */
@@ -127,6 +135,7 @@ export async function attachRecordedSubmissions(admitted, terminal, scope) {
 /**
  * Host ended with no recorded submission — lawful no_receipt (exit 0).
  * Does not invent an output failure for an empty ledger.
+ * #953: empty public terminal face — clear every reader-adoptable prior face.
  */
 export async function settleHostEndedNoReceipt(admitted, authority, scope) {
     const facts = noReceiptLifecycleFacts({
@@ -137,6 +146,7 @@ export async function settleHostEndedNoReceipt(admitted, authority, scope) {
         attemptPointer: `current:${admitted.runDirectory}`,
     });
     const coordinates = coordinatesFromAdmitted(authority, admitted);
+    await clearOppositeTerminalArtifactFace(admitted.runDirectory);
     return withOptionalGateProjection({
         roleOutcome: {
             kind: "no_receipt",
@@ -157,7 +167,7 @@ async function closedLedgerOutcome(admitted, role, scope) {
 function coordinatesFromAdmitted(authority, admitted) {
     return authority.decode(admitted.principal);
 }
-import { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, adviceNavigatorFact, } from "./terminal.js";
+import { coalesceSubmissionRows, exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, adviceNavigatorFact, } from "./terminal.js";
 export { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, };
 /**
  * Host stderr as recorded — full bytes, no flood filter, no char clip (#836).
@@ -470,6 +480,13 @@ function isMissingPathError(error) {
         "code" in error &&
         error.code === "ENOENT");
 }
+/** Face clear only: path not enterable as a face (ENOENT or file mid-path). */
+function isAbsentFacePathError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        (error.code === "ENOENT" ||
+            error.code === "ENOTDIR"));
+}
 /**
  * Preserve session-read failure identity as a typed session cause.
  * SyntaxError keeps its name so durable settlement does not wash malformed JSONL
@@ -1644,72 +1661,131 @@ async function extractNavigatorFactFromAdmittedSession(sessionFile) {
         };
     }
 }
-export async function publishJudgeArtifacts(admitted, roleOutcome, coordinates) {
+/**
+ * Remove one face path (file or directory collision plant).
+ * Only missing target is silent — other errno stay loud (失败诚实).
+ * recursive: publication may have occupied a face name as a directory (EISDIR plant).
+ */
+async function removeFaceIfPresent(path) {
+    try {
+        await rm(path, { recursive: true, force: true });
+    }
+    catch (error) {
+        // force:true already ignores ENOENT; ENOTDIR = face path not enterable
+        // (artifacts-as-file mid-path) — same absent-face semantics as the reader.
+        // Other errno stay loud (失败诚实).
+        if (isAbsentFacePathError(error))
+            return;
+        throw error;
+    }
+}
+/**
+ * #953: artifact face reflects the current terminal only.
+ * Reader contract owns the full adoptable set (conventional trio + fixed
+ * fallbacks + seam-owned unique). Clear every seam-owned face before the
+ * new current publishes — including the conventional name about to be
+ * rewritten. Retaining that name left directory collision plants in place
+ * (supported publish input); writer then fell back while the reader stopped
+ * at EISDIR on the stale conventional path and never adopted the fallback.
+ * report / error / empty share one method (no per-branch face list).
+ * empty publishes nothing; does not create a no_receipt-shaped public artifact.
+ * Non-terminal materials stay. Face names may be directory collision plants —
+ * remove recursively. Unique ownership is listSeamOwnedUniqueErrorFacePaths:
+ * parent runs/ faces clear only when body.runId binds; unparseable runId → none.
+ * Path absence (ENOENT/ENOTDIR) is silent; other delete failures stay loud.
+ */
+async function clearOppositeTerminalArtifactFace(runDirectory) {
+    const artifactsDir = roleRunArtifactsDirectory(runDirectory);
+    for (const file of RUN_TERMINAL_ARTIFACT_FILES) {
+        await removeFaceIfPresent(join(artifactsDir, file));
+    }
+    // Fixed fallbacks + unique clear too; subsequent publish writes the new
+    // durable path after this clear (conventional first when writable).
+    for (const relative of RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS) {
+        await removeFaceIfPresent(join(runDirectory, relative));
+    }
+    for (const path of await listSeamOwnedUniqueErrorFacePaths(runDirectory)) {
+        await removeFaceIfPresent(path);
+    }
+}
+async function ensureTerminalArtifactFace(runDirectory) {
+    const artifactsDir = await ensureRunArtifactsDir(runDirectory);
+    await clearOppositeTerminalArtifactFace(runDirectory);
+    return artifactsDir;
+}
+function acceptedArtifactAttachmentRefs(attachments) {
+    return attachments.map((a) => ({
+        provenancePath: a.provenancePath,
+        frozenPath: a.frozenPath,
+        sha256: a.sha256,
+        byteLength: a.byteLength,
+    }));
+}
+/**
+ * Sole success-terminal artifact publisher (#953): append attempt history,
+ * refresh the public terminal face, write report/evidence, return refs.
+ * Seat-specific structured fields stay in callers; do not fork this flow.
+ */
+async function publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, bodies) {
     // #419: history first — report/evidence stay last-write-wins views only
     // because every attempt's complete result has already been appended.
-    await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
-    const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-    const reportPath = join(artifactsDir, "report.json");
-    const evidencePath = join(artifactsDir, "evidence.json");
-    await writeFile(reportPath, `${JSON.stringify({
-        role: "judge",
-        runId: admitted.runId,
-        outcome: roleOutcome,
-    }, null, 2)}\n`, "utf8");
-    await writeFile(evidencePath, `${JSON.stringify({
+    await appendRunAttemptHistory({
+        role: admitted.role,
         runId: admitted.runId,
-        sessionDirectory: coordinates.sessionDirectory,
         sessionFile: coordinates.sessionFile,
-        admittedRequestPath: admitted.admittedRequestPath,
-        attachments: admitted.attachments.map((a) => ({
-            provenancePath: a.provenancePath,
-            frozenPath: a.frozenPath,
-            sha256: a.sha256,
-            byteLength: a.byteLength,
-        })),
-    }, null, 2)}\n`, "utf8");
+    }, roleOutcome);
+    const artifactsDir = await ensureTerminalArtifactFace(admitted.runDirectory);
+    const reportPath = join(artifactsDir, "report.json");
+    const evidencePath = join(artifactsDir, "evidence.json");
+    await writeFile(reportPath, `${JSON.stringify(bodies.report, null, 2)}\n`, "utf8");
+    await writeFile(evidencePath, `${JSON.stringify(bodies.evidence, null, 2)}\n`, "utf8");
     return [
         { kind: "report", path: reportPath },
         { kind: "evidence", path: evidencePath },
     ];
 }
+export async function publishJudgeArtifacts(admitted, roleOutcome, coordinates) {
+    return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
+        report: {
+            role: "judge",
+            runId: admitted.runId,
+            outcome: roleOutcome,
+        },
+        evidence: {
+            runId: admitted.runId,
+            sessionDirectory: coordinates.sessionDirectory,
+            sessionFile: coordinates.sessionFile,
+            admittedRequestPath: admitted.admittedRequestPath,
+            attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+        },
+    });
+}
 /**
  * Publish lawful Coder success Artifacts on the shared #106 success interface.
  * Evidence records package method provenance without ambient home Skill paths.
  */
 export async function publishCoderArtifacts(admitted, roleOutcome, coordinates, options = {}) {
-    await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
-    const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-    const reportPath = join(artifactsDir, "report.json");
-    const evidencePath = join(artifactsDir, "evidence.json");
-    await writeFile(reportPath, `${JSON.stringify({
-        role: "coder",
-        runId: admitted.runId,
-        phase: admitted.phase,
-        outcome: roleOutcome,
-    }, null, 2)}\n`, "utf8");
-    await writeFile(evidencePath, `${JSON.stringify({
-        runId: admitted.runId,
-        role: "coder",
-        phase: admitted.phase,
-        sessionDirectory: coordinates.sessionDirectory,
-        sessionFile: coordinates.sessionFile,
-        admittedRequestPath: admitted.admittedRequestPath,
-        taskPath: admitted.taskPath,
-        attachments: admitted.attachments.map((a) => ({
-            provenancePath: a.provenancePath,
-            frozenPath: a.frozenPath,
-            sha256: a.sha256,
-            byteLength: a.byteLength,
-        })),
-        ...(options.methodProvenance === undefined
-            ? {}
-            : { methodProvenance: options.methodProvenance }),
-    }, null, 2)}\n`, "utf8");
-    return [
-        { kind: "report", path: reportPath },
-        { kind: "evidence", path: evidencePath },
-    ];
+    return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
+        report: {
+            role: "coder",
+            runId: admitted.runId,
+            phase: admitted.phase,
+            outcome: roleOutcome,
+        },
+        evidence: {
+            runId: admitted.runId,
+            role: "coder",
+            phase: admitted.phase,
+            sessionDirectory: coordinates.sessionDirectory,
+            sessionFile: coordinates.sessionFile,
+            admittedRequestPath: admitted.admittedRequestPath,
+            taskPath: admitted.taskPath,
+            attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+            ...(options.methodProvenance === undefined
+                ? {}
+                : { methodProvenance: options.methodProvenance }),
+        },
+    });
 }
 /**
  * Read session entries for lawful settlement. Missing path → undefined (absence).
@@ -1861,43 +1937,32 @@ export function extractFixerMethodInvocations(entries, options) {
  * Evidence records package diagnosis provenance and optional observed invocation.
  */
 export async function publishFixerArtifacts(admitted, roleOutcome, coordinates, options) {
-    await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
-    const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-    const reportPath = join(artifactsDir, "report.json");
-    const evidencePath = join(artifactsDir, "evidence.json");
-    await writeFile(reportPath, `${JSON.stringify({
-        role: "fixer",
-        runId: admitted.runId,
-        phase: admitted.phase,
-        outcome: roleOutcome,
-    }, null, 2)}\n`, "utf8");
-    await writeFile(evidencePath, `${JSON.stringify({
-        runId: admitted.runId,
-        role: "fixer",
-        phase: admitted.phase,
-        sessionDirectory: coordinates.sessionDirectory,
-        sessionFile: coordinates.sessionFile,
-        admittedRequestPath: admitted.admittedRequestPath,
-        packetPath: admitted.packetPath,
-        ...(admitted.prerequisitesPath === undefined
-            ? {}
-            : { prerequisitesPath: admitted.prerequisitesPath }),
-        prerequisites: admitted.prerequisites,
-        attachments: admitted.attachments.map((a) => ({
-            provenancePath: a.provenancePath,
-            frozenPath: a.frozenPath,
-            sha256: a.sha256,
-            byteLength: a.byteLength,
-        })),
-        methodProvenance: options.methodProvenance,
-        // Optional diagnosis: availability is package-bound; invocation only when observed.
-        methodInvocationObserved: (options.methodInvocations ?? []).length > 0,
-        methodInvocations: options.methodInvocations ?? [],
-    }, null, 2)}\n`, "utf8");
-    return [
-        { kind: "report", path: reportPath },
-        { kind: "evidence", path: evidencePath },
-    ];
+    return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
+        report: {
+            role: "fixer",
+            runId: admitted.runId,
+            phase: admitted.phase,
+            outcome: roleOutcome,
+        },
+        evidence: {
+            runId: admitted.runId,
+            role: "fixer",
+            phase: admitted.phase,
+            sessionDirectory: coordinates.sessionDirectory,
+            sessionFile: coordinates.sessionFile,
+            admittedRequestPath: admitted.admittedRequestPath,
+            packetPath: admitted.packetPath,
+            ...(admitted.prerequisitesPath === undefined
+                ? {}
+                : { prerequisitesPath: admitted.prerequisitesPath }),
+            prerequisites: admitted.prerequisites,
+            attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+            methodProvenance: options.methodProvenance,
+            // Optional diagnosis: availability is package-bound; invocation only when observed.
+            methodInvocationObserved: (options.methodInvocations ?? []).length > 0,
+            methodInvocations: options.methodInvocations ?? [],
+        },
+    });
 }
 async function settleLawfulFixerTerminalResult(admitted, authority, options, scope) {
     const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer", scope);
@@ -1934,35 +1999,24 @@ export async function settleFixerTerminalResult(admitted, authority, options, sc
     return settled;
 }
 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");
-    const evidencePath = join(artifactsDir, "evidence.json");
-    await writeFile(reportPath, `${JSON.stringify({
-        role: "collector",
-        runId: admitted.runId,
-        outcome: roleOutcome,
-    }, null, 2)}\n`, "utf8");
-    await writeFile(evidencePath, `${JSON.stringify({
-        runId: admitted.runId,
-        role: "collector",
-        ...(admitted.prNumber === undefined ? {} : { prNumber: admitted.prNumber }),
-        repository: admitted.repository.canonical,
-        manifestDigest: admitted.manifestDigest,
-        sessionDirectory: coordinates.sessionDirectory,
-        sessionFile: coordinates.sessionFile,
-        admittedRequestPath: admitted.admittedRequestPath,
-        attachments: admitted.attachments.map((a) => ({
-            provenancePath: a.provenancePath,
-            frozenPath: a.frozenPath,
-            sha256: a.sha256,
-            byteLength: a.byteLength,
-        })),
-    }, null, 2)}\n`, "utf8");
-    return [
-        { kind: "report", path: reportPath },
-        { kind: "evidence", path: evidencePath },
-    ];
+    return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
+        report: {
+            role: "collector",
+            runId: admitted.runId,
+            outcome: roleOutcome,
+        },
+        evidence: {
+            runId: admitted.runId,
+            role: "collector",
+            ...(admitted.prNumber === undefined ? {} : { prNumber: admitted.prNumber }),
+            repository: admitted.repository.canonical,
+            manifestDigest: admitted.manifestDigest,
+            sessionDirectory: coordinates.sessionDirectory,
+            sessionFile: coordinates.sessionFile,
+            admittedRequestPath: admitted.admittedRequestPath,
+            attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+        },
+    });
 }
 async function settleLawfulCollectorTerminalResult(admitted, authority, scope) {
     const coordinates = coordinatesFromAdmitted(authority, admitted);
@@ -2047,37 +2101,28 @@ function extractDoctorCandidateAuditNoReceiptFact(entries) {
     return undefined;
 }
 export async function publishDoctorArtifacts(admitted, roleOutcome, coordinates, options = {}) {
-    await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
-    const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-    const reportPath = join(artifactsDir, "report.json");
-    const evidencePath = join(artifactsDir, "evidence.json");
-    await writeFile(reportPath, `${JSON.stringify({
-        role: "doctor",
-        runId: admitted.runId,
-        outcome: roleOutcome,
-        ...(options.cost === undefined ? {} : { cost: options.cost }),
-        ...(options.auditNoReceipt === undefined ? {} : { auditNoReceipt: options.auditNoReceipt }),
-    }, null, 2)}\n`, "utf8");
-    await writeFile(evidencePath, `${JSON.stringify({
-        runId: admitted.runId,
-        role: "doctor",
-        issueNumber: admitted.issueNumber,
-        caseRunsPath: admitted.caseRunsPath,
-        caseIdentity: admitted.caseIdentity,
-        sessionDirectory: coordinates.sessionDirectory,
-        sessionFile: coordinates.sessionFile,
-        admittedRequestPath: admitted.admittedRequestPath,
-        attachments: admitted.attachments.map((a) => ({
-            provenancePath: a.provenancePath,
-            frozenPath: a.frozenPath,
-            sha256: a.sha256,
-            byteLength: a.byteLength,
-        })),
-    }, null, 2)}\n`, "utf8");
-    return [
-        { kind: "report", path: reportPath },
-        { kind: "evidence", path: evidencePath },
-    ];
+    return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
+        report: {
+            role: "doctor",
+            runId: admitted.runId,
+            outcome: roleOutcome,
+            ...(options.cost === undefined ? {} : { cost: options.cost }),
+            ...(options.auditNoReceipt === undefined
+                ? {}
+                : { auditNoReceipt: options.auditNoReceipt }),
+        },
+        evidence: {
+            runId: admitted.runId,
+            role: "doctor",
+            issueNumber: admitted.issueNumber,
+            caseRunsPath: admitted.caseRunsPath,
+            caseIdentity: admitted.caseIdentity,
+            sessionDirectory: coordinates.sessionDirectory,
+            sessionFile: coordinates.sessionFile,
+            admittedRequestPath: admitted.admittedRequestPath,
+            attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+        },
+    });
 }
 async function settleLawfulDoctorTerminalResult(admitted, authority, scope) {
     const sealed = await sealedLedgerOutcome(admitted, "doctor", scope);
@@ -2132,6 +2177,25 @@ function currentAttemptStartIndex(entries) {
     }
     return 0;
 }
+/**
+ * Filed-seat success face via the sole accepted publisher (#953).
+ */
+async function publishSeatAcceptedArtifacts(admitted, roleOutcome, coordinates) {
+    return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
+        report: {
+            role: admitted.role,
+            runId: admitted.runId,
+            outcome: roleOutcome,
+        },
+        evidence: {
+            runId: admitted.runId,
+            sessionDirectory: coordinates.sessionDirectory,
+            sessionFile: coordinates.sessionFile,
+            admittedRequestPath: admitted.admittedRequestPath,
+            attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+        },
+    });
+}
 async function settleLawfulSeatAcceptedTerminalResult(admitted, authority, spec, scope) {
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const { sessionDirectory, sessionFile } = coordinates;
@@ -2169,10 +2233,11 @@ async function settleLawfulSeatAcceptedTerminalResult(admitted, authority, spec,
     const roleOutcome = await closedLedgerOutcome(admitted, spec.role, scope);
     if (roleOutcome !== undefined && (thisAttemptHasSeatSuccess || residual === undefined)) {
         const navigator = extractNavigatorFact(entries);
+        const artifacts = await publishSeatAcceptedArtifacts(admitted, roleOutcome, coordinates);
         return withSubmissions(await withOptionalGateProjection({
             roleOutcome,
             navigator,
-            artifacts: [],
+            artifacts,
             runId: admitted.runId,
         }, sessionDirectory, detourGateContext(admitted, scope)), submissions);
     }
@@ -2433,42 +2498,31 @@ export function extractReviewerMethodInvocations(entries, options) {
  * observation without ambient home Skill paths.
  */
 export async function publishReviewerArtifacts(admitted, roleOutcome, coordinates, options) {
-    await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
-    const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-    const reportPath = join(artifactsDir, "report.json");
-    const evidencePath = join(artifactsDir, "evidence.json");
-    await writeFile(reportPath, `${JSON.stringify({
-        role: "reviewer",
-        runId: admitted.runId,
-        outcome: roleOutcome,
-    }, null, 2)}\n`, "utf8");
-    await writeFile(evidencePath, `${JSON.stringify({
-        runId: admitted.runId,
-        role: "reviewer",
-        sessionDirectory: coordinates.sessionDirectory,
-        sessionFile: coordinates.sessionFile,
-        admittedRequestPath: admitted.admittedRequestPath,
-        baseRevision: admitted.baseRevision,
-        lens: admitted.lens,
-        authorityRefs: [...admitted.authorityRefs],
-        ...(admitted.instructionEmpty
-            ? {}
-            : { callerProvenance: admitted.instruction }),
-        attachments: admitted.attachments.map((a) => ({
-            provenancePath: a.provenancePath,
-            frozenPath: a.frozenPath,
-            sha256: a.sha256,
-            byteLength: a.byteLength,
-        })),
-        methodProvenance: options.methodProvenance,
-        // Forced package method: availability is package-bound; expansion only when observed.
-        methodInvocationObserved: (options.methodInvocations ?? []).length > 0,
-        methodInvocations: options.methodInvocations ?? [],
-    }, null, 2)}\n`, "utf8");
-    return [
-        { kind: "report", path: reportPath },
-        { kind: "evidence", path: evidencePath },
-    ];
+    return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
+        report: {
+            role: "reviewer",
+            runId: admitted.runId,
+            outcome: roleOutcome,
+        },
+        evidence: {
+            runId: admitted.runId,
+            role: "reviewer",
+            sessionDirectory: coordinates.sessionDirectory,
+            sessionFile: coordinates.sessionFile,
+            admittedRequestPath: admitted.admittedRequestPath,
+            baseRevision: admitted.baseRevision,
+            lens: admitted.lens,
+            authorityRefs: [...admitted.authorityRefs],
+            ...(admitted.instructionEmpty
+                ? {}
+                : { callerProvenance: admitted.instruction }),
+            attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+            methodProvenance: options.methodProvenance,
+            // Forced package method: availability is package-bound; expansion only when observed.
+            methodInvocationObserved: (options.methodInvocations ?? []).length > 0,
+            methodInvocations: options.methodInvocations ?? [],
+        },
+    });
 }
 async function settleLawfulReviewerTerminalResult(admitted, authority, options, scope) {
     const sealed = await sealedLedgerOutcome(admitted, "reviewer", scope);
@@ -2538,37 +2592,26 @@ export function extractMergerMethodInvocations(entries, options) {
  * adapter-derived mechanical envelope facts without ambient home Skill paths.
  */
 export async function publishMergerArtifacts(admitted, roleOutcome, coordinates, options) {
-    await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
-    const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-    const reportPath = join(artifactsDir, "report.json");
-    const evidencePath = join(artifactsDir, "evidence.json");
-    await writeFile(reportPath, `${JSON.stringify({
-        role: "merger",
-        runId: admitted.runId,
-        outcome: roleOutcome,
-    }, null, 2)}\n`, "utf8");
-    await writeFile(evidencePath, `${JSON.stringify({
-        runId: admitted.runId,
-        role: "merger",
-        sessionDirectory: coordinates.sessionDirectory,
-        sessionFile: coordinates.sessionFile,
-        admittedRequestPath: admitted.admittedRequestPath,
-        mergerInputPath: admitted.mergerInputPath,
-        derived: admitted.derived,
-        attachments: admitted.attachments.map((a) => ({
-            provenancePath: a.provenancePath,
-            frozenPath: a.frozenPath,
-            sha256: a.sha256,
-            byteLength: a.byteLength,
-        })),
-        methodProvenance: options.methodProvenance,
-        methodInvocationObserved: (options.methodInvocations ?? []).length > 0,
-        methodInvocations: options.methodInvocations ?? [],
-    }, null, 2)}\n`, "utf8");
-    return [
-        { kind: "report", path: reportPath },
-        { kind: "evidence", path: evidencePath },
-    ];
+    return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
+        report: {
+            role: "merger",
+            runId: admitted.runId,
+            outcome: roleOutcome,
+        },
+        evidence: {
+            runId: admitted.runId,
+            role: "merger",
+            sessionDirectory: coordinates.sessionDirectory,
+            sessionFile: coordinates.sessionFile,
+            admittedRequestPath: admitted.admittedRequestPath,
+            mergerInputPath: admitted.mergerInputPath,
+            derived: admitted.derived,
+            attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+            methodProvenance: options.methodProvenance,
+            methodInvocationObserved: (options.methodInvocations ?? []).length > 0,
+            methodInvocations: options.methodInvocations ?? [],
+        },
+    });
 }
 async function settleLawfulMergerTerminalResult(admitted, authority, options, scope) {
     const coordinates = coordinatesFromAdmitted(authority, admitted);
@@ -2710,6 +2753,17 @@ export async function publishFailureArtifacts(admitted, failure, authority) {
     const { sessionDirectory, sessionFile } = coordinatesFromAdmitted(authority, admitted);
     const { baseDir, attempt: baseAttempt } = await resolveFailureArtifactsBase(admitted.runDirectory);
     const priorIssues = baseAttempt === undefined ? [] : [baseAttempt];
+    // #953: failure face must not leave a prior success report as the durable view.
+    // Clear failure must not strand the original controlled failure outside
+    // settlement — same as history failure below, it rides publicationIssues
+    // and unique fallback still places the durable error (locked artifacts/ +
+    // prior face must not abort publishFailureArtifacts).
+    try {
+        await clearOppositeTerminalArtifactFace(admitted.runDirectory);
+    }
+    catch (error) {
+        priorIssues.push(publicationAttemptFromError(roleRunArtifactsDirectory(admitted.runDirectory), error));
+    }
     // #419: each attempt's complete failure result joins the appended history
     // before any fixed-name artifact view is rewritten. History failure must not
     // strand the original controlled failure outside settlement — it rides
@@ -2803,32 +2857,47 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
             const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => 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) {
+                // Catch only covers lifecycle-byte parse. Clear / navigator / gate I/O
+                // after a valid parse must keep their real failure identity (#953).
+                let facts;
                 try {
-                    const facts = parseNoReceiptLifecycleFacts(raw);
-                    if (facts.runPointer === admitted.runDirectory && facts.attemptPointer === `current:${admitted.runDirectory}`) {
-                        let decisiveFacts = facts;
-                        // #676 D1/J3: project durable bind-target rejection onto public no_receipt facts.
-                        if (admitted.role === "collector") {
-                            const bindRejection = extractCollectorTargetBindRejection(entries.slice(attemptStart));
-                            if (bindRejection !== undefined) {
-                                decisiveFacts = {
-                                    ...facts,
-                                    targetBindRejected: true,
-                                    targetBindDiagnostic: bindRejection.diagnostic,
-                                    ...(bindRejection.code === undefined ? {} : { targetBindCode: bindRejection.code }),
-                                };
-                            }
+                    facts = parseNoReceiptLifecycleFacts(raw);
+                }
+                catch {
+                    /* malformed lifecycle bytes remain the existing nonzero output failure */
+                }
+                if (facts !== undefined &&
+                    facts.runPointer === admitted.runDirectory &&
+                    facts.attemptPointer === `current:${admitted.runDirectory}`) {
+                    let decisiveFacts = facts;
+                    // #676 D1/J3: project durable bind-target rejection onto public no_receipt facts.
+                    if (admitted.role === "collector") {
+                        const bindRejection = extractCollectorTargetBindRejection(entries.slice(attemptStart));
+                        if (bindRejection !== undefined) {
+                            decisiveFacts = {
+                                ...facts,
+                                targetBindRejected: true,
+                                targetBindDiagnostic: bindRejection.diagnostic,
+                                ...(bindRejection.code === undefined ? {} : { targetBindCode: bindRejection.code }),
+                            };
                         }
-                        // #478: no_receipt is still a public Terminal — project accepted gate facts.
-                        return withOptionalGateProjection({
-                            roleOutcome: { kind: "no_receipt", role: admitted.role, status: "no-accepted-receipt", ...facts, decisiveFacts },
-                            navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
-                            artifacts: [],
-                            runId: admitted.runId,
-                        }, sessionDirectory, detourGateContext(admitted, options));
                     }
+                    // #478: no_receipt is still a public Terminal — project accepted gate facts.
+                    // #953: empty public terminal face — clear every reader-adoptable prior face.
+                    await clearOppositeTerminalArtifactFace(admitted.runDirectory);
+                    return withOptionalGateProjection({
+                        roleOutcome: {
+                            kind: "no_receipt",
+                            role: admitted.role,
+                            status: "no-accepted-receipt",
+                            ...facts,
+                            decisiveFacts,
+                        },
+                        navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
+                        artifacts: [],
+                        runId: admitted.runId,
+                    }, sessionDirectory, detourGateContext(admitted, options));
                 }
-                catch { /* malformed lifecycle bytes remain the existing nonzero output failure */ }
             }
         }
     }