@akagilnc/pi-workflow-roles 0.1.4800 → 0.1.4870

package/dist/public-cli/settlement.js

@@ -11,8 +11,6 @@ import { readSitianRecords, resolveSitianRecordPath, sitianReport } from "../sit
 import { hasFreshAttemptSubmission, readAttemptScopedSubmissionRows, readRecordedSubmissionRows, readRecordedSubmissions, } from "../submission-ledger.js";
 import { isAuditEscalationResult } from "../audit-escalation.js";
 import { AUDITOR_SOUL_ROLES } from "../auditor-soul.js";
-import { DOCTOR_AUDIT_TOOL_NAME } from "../doctor-auditor.js";
-import { JUDGE_AUDIT_TOOL_NAME } from "../judge-auditor.js";
 import { knownFailureFromProviderStop } from "../pi/known-failure.js";
 import { isV1ResumableProvider, readLatestTypedProviderHttpObservation, readTypedHttp429Observation, } from "./run-lifecycle.js";
 import { AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE, AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE, COMPLIANCE_RESPONSE_ENTRY_TYPE, readComplianceCandidate, } from "../compliance-transport.js";
@@ -27,17 +25,9 @@ import { CODER_OUTPUT_TOOL_NAME, FIXER_OUTPUT_TOOL_NAME, } from "../package-cont
 import { DOCTOR_OUTPUT_TOOL_NAME, } from "../doctor-contracts.js";
 import { DOCTOR_CANDIDATE_ENTRY_TYPE } from "../dossier-resolution.js";
 import { REVIEWER_OUTPUT_TOOL_NAME, } from "../package-contracts/reviewer-output.js";
-import { MERGER_OUTPUT_TOOL_NAME, } from "../merger-contracts.js";
-import { NOTARY_OUTPUT_TOOL_NAME, } from "../notary-contracts.js";
-import { COUNTERSIGN_OUTPUT_TOOL_NAME, } from "../countersign-contracts.js";
-import { GLEANER_LEFT_OUTPUT_TOOL_NAME, } from "../gleaner-left-contracts.js";
-import { DIARIST_OUTPUT_TOOL_NAME, } from "../diarist-contracts.js";
-import { SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY, SECRETARIAT_GATE_OFFICER_ENTRY_TYPE, SECRETARIAT_OUTPUT_TOOL_NAME, } from "../secretariat-contracts.js";
-import { INSPECTOR_OUTPUT_TOOL_NAME, } from "../inspector-contracts.js";
-import { GATEKEEPER_OUTPUT_TOOL_NAME, } from "../package-contracts/gatekeeper-output.js";
-import { NAVIGATOR_OUTPUT_TOOL_NAME, } from "../package-contracts/navigator-output.js";
-import { AUDITOR_OUTPUT_TOOL_NAME, } from "../package-contracts/auditor-output.js";
-import { observePackagedMethodSkillInvocation, } from "../package-resources/method-skill.js";
+import { packagedAuditToolName, packagedDurableOfficerEntry, packagedProjectsTargetBindRejection, packagedRoleAcceptedOutputTool, packagedRoleMetadata, packagedSkipsGateOnInfrastructureStage, } from "../packaged-role-registry.js";
+import { SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY, SECRETARIAT_GATE_OFFICER_ENTRY_TYPE, } from "../secretariat-contracts.js";
+import { observePackagedMethodSkillInvocation, resolvePackagedMethodSkillPath, } from "../package-resources/method-skill.js";
 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";
@@ -160,9 +150,6 @@ export async function settleHostEndedNoReceipt(admitted, authority, scope) {
         runId: admitted.runId,
     }, coordinates.sessionDirectory, detourGateContext(admitted, scope));
 }
-async function closedLedgerOutcome(admitted, role, scope) {
-    return sealedLedgerOutcome(admitted, role, scope);
-}
 /** Transitional host-session reads remain only for non-sealed failure and audit evidence. */
 function coordinatesFromAdmitted(authority, admitted) {
     return authority.decode(admitted.principal);
@@ -1153,13 +1140,52 @@ export function extractEngineDetourInfrastructureFailure(entries) {
 export async function readEngineDetourInfrastructureFailure(sessionFile) {
     return readInfrastructureToolFailure(sessionFile, ENGINE_DETOUR_INFRASTRUCTURE_FAILURE_SPEC);
 }
+function knownFailureFromControlled(failure) {
+    return {
+        ...(failure.cause === undefined ? {} : { cause: failure.cause }),
+        diagnostic: failure.diagnostic,
+        ...(failure.identity === undefined ? {} : { identity: failure.identity }),
+    };
+}
+const RUNNER_FAILURE_POLICY = {
+    "engine-detour-known-first": {
+        read: readEngineDetourInfrastructureFailure,
+        rank: "known-first",
+    },
+    "engine-detour-record-first": {
+        read: readEngineDetourInfrastructureFailure,
+        rank: "record-first",
+    },
+    "collector-known-first": {
+        read: readCollectorInfrastructureFailure,
+        rank: "known-first",
+    },
+};
+/**
+ * Runner-failure rank for one seat. The composition-root `runnerFailure`
+ * leaf is the only seat difference; absent means the runner knownFailure stands.
+ */
+export function seatKnownFailureResolver(role) {
+    const record = packagedRoleMetadata(role);
+    if (record === undefined || !("runnerFailure" in record))
+        return undefined;
+    const policy = RUNNER_FAILURE_POLICY[record.runnerFailure];
+    return async ({ result, sessionFile }) => {
+        const infrastructureFailure = await policy.read(sessionFile);
+        if (policy.rank === "record-first") {
+            return infrastructureFailure === undefined
+                ? result.knownFailure
+                : knownFailureFromControlled(infrastructureFailure);
+        }
+        return result.knownFailure ?? (infrastructureFailure === undefined ? undefined : knownFailureFromControlled(infrastructureFailure));
+    };
+}
 function auditToolNameForRole(role) {
-    switch (role) {
-        case "judge":
-            return JUDGE_AUDIT_TOOL_NAME;
-        case "doctor":
-            return DOCTOR_AUDIT_TOOL_NAME;
+    const name = packagedAuditToolName(role);
+    if (name === undefined) {
+        throw new Error(`audit tool is not declared for ${role}`);
     }
+    return name;
 }
 function boundRoleToolCallForResult(entries, resultIndex, message, outputToolName) {
     const callId = message.toolCallId;
@@ -1560,9 +1586,7 @@ async function withOptionalGateProjection(base, sessionDirectory, gateContext =
         : undefined;
     const skipGate = isRecord(secondaryEvidence)
         && secondaryEvidence.kind === "role_infrastructure_failure"
-        && (secondaryEvidence.stage === "gatekeeper"
-            || secondaryEvidence.stage === "inspector"
-            || secondaryEvidence.stage === "notary");
+        && packagedSkipsGateOnInfrastructureStage(secondaryEvidence.stage);
     let next = base;
     if (!skipGate) {
         // Defaults live solely in extractGateFactFromSessionDirectory — do not re-derive.
@@ -1744,48 +1768,9 @@ async function publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinat
         { 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 = {}) {
-    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 }),
-        },
-    });
+/** Publish one accepted seat's report/evidence face from the shared leaf table. */
+export async function publishSeatAcceptedArtifacts(admitted, roleOutcome, coordinates, entries = [], options = {}) {
+    return publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries, options);
 }
 /**
  * Read session entries for lawful settlement. Missing path → undefined (absence).
@@ -1807,85 +1792,105 @@ async function readLawfulSettlementEntries(sessionFile) {
     }
 }
 /**
- * Lawful Judge outcome presence only — no artifact publication.
- * Returns undefined for genuine absence (missing path / no lawful verdict).
- * Session-read failures propagate with typed identity.
+ * Sealed-ledger seats that publish on a lawful outcome and do not scan a
+ * residual tool or attach run-scoped submission history.
+ * Absence stays undefined. Session-read and publication errors keep their identity.
+ * Outcome is read before publication so a later write error cannot erase it.
  */
-export async function readLawfulJudgeRoleOutcome(admitted, authority, scope) {
-    return sealedLedgerOutcome(admitted, "judge", scope);
-}
-/**
- * Single lawful-settlement implementation (session → outcome/Navigator/artifacts).
- *
- * - Returns undefined only for genuine absence (missing session path, or no
- *   lawful verdict in an otherwise readable session).
- * - Malformed JSONL / other session-read failures throw with knownCause=session
- *   and original identity (SyntaxError name retained).
- * - Artifact publication failures propagate with their original typed identity.
- * - Lawful outcome presence is decided before publication so a later write error
- *   cannot erase the fact that a lawful result already exists.
- */
-async function settleLawfulJudgeTerminalResult(admitted, authority, scope) {
-    const roleOutcome = await readLawfulJudgeRoleOutcome(admitted, authority, scope);
+async function settleSealedLedgerTerminal(admitted, authority, scope, publish, accept) {
+    const roleOutcome = await sealedLedgerOutcome(admitted, admitted.role, scope);
     if (roleOutcome === undefined)
         return undefined;
+    if (accept !== undefined && !accept(roleOutcome))
+        return undefined;
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const entries = await readLawfulSettlementEntries(coordinates.sessionFile) ?? [];
-    const navigator = extractNavigatorFact(entries);
-    // Lawful outcome exists — artifact publication keeps original errno/name.
-    const artifacts = await publishJudgeArtifacts(admitted, roleOutcome, coordinates);
+    const artifacts = await publish(roleOutcome, coordinates, entries);
     return withOptionalGateProjection({
         roleOutcome,
-        navigator,
+        navigator: extractNavigatorFact(entries),
         artifacts,
         runId: admitted.runId,
     }, coordinates.sessionDirectory, detourGateContext(admitted, scope));
 }
 /**
- * Settle a lawful typed terminal result from the admitted session.
- * Throws when no lawful outcome is present (tests/callers that require success).
- * Session-read and publication failures retain their typed identity.
+ * Sealed accepted outcome publishes. Any other ledger face falls through to
+ * the latest bound errored tool result in the scan window, which settles as
+ * output failure. Both faces attach run-scoped submissions. Absence of both
+ * stays undefined. Session is read first so a read failure keeps its identity
+ * even when the ledger has no accepted row.
  */
-export async function settleJudgeTerminalResult(admitted, authority, scope) {
-    const settled = await settleLawfulJudgeTerminalResult(admitted, authority, scope);
-    if (settled === undefined) {
-        throw new Error("Judge Role run completed without a lawful typed terminal result");
+async function settleSealedAcceptedOrToolResidual(admitted, authority, scope, role, residualToolName, scan, publish) {
+    const coordinates = coordinatesFromAdmitted(authority, admitted);
+    const { sessionDirectory, sessionFile } = coordinates;
+    const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
+    const roleOutcome = await sealedLedgerOutcome(admitted, role, scope);
+    if (roleOutcome?.role !== role || roleOutcome.kind !== "accepted") {
+        const scanStart = scan === "current-attempt" ? currentAttemptStartIndex(entries) : 0;
+        for (let index = entries.length - 1; index >= scanStart; index -= 1) {
+            const message = entries[index]?.message;
+            if (message?.role !== "toolResult")
+                continue;
+            const residual = boundErroredToolCandidate(entries, index, message, residualToolName);
+            if (residual === undefined)
+                continue;
+            const candidate = residual.candidate;
+            const details = isRecord(candidate) ? candidate : { candidate };
+            const failed = await settleFailureTerminalResult(admitted, {
+                cause: "output",
+                diagnostic: residual.diagnostic,
+                details,
+            }, authority, scope ?? {});
+            return attachRecordedSubmissions(admitted, failed, scope);
+        }
+        return undefined;
     }
-    return settled;
+    const artifacts = await publish(roleOutcome, coordinates, entries);
+    return attachRecordedSubmissions(admitted, await withOptionalGateProjection({
+        roleOutcome,
+        navigator: extractNavigatorFact(entries),
+        artifacts,
+        runId: admitted.runId,
+    }, sessionDirectory, detourGateContext(admitted, scope)), scope);
 }
 /**
- * Try to settle a lawful typed terminal result from the admitted session.
- * Returns undefined only for genuine absence (no lawful verdict / missing path).
- * Session malformation and publication exceptions propagate with typed identity.
+ * One settlement for every registered seat. The registry `settlement` leaf
+ * picks sealed ledger, sealed-or-residual, or the accepted-tool scan.
+ * Seat evidence and the observed-method tail stay on the artifact face.
  */
-export async function trySettleJudgeTerminalResult(admitted, authority, scope) {
-    return settleLawfulJudgeTerminalResult(admitted, authority, scope);
+async function settleSeat(admitted, authority, scope, options) {
+    const record = packagedRoleMetadata(admitted.role);
+    if (record === undefined) {
+        throw new Error(`no settlement for ${admitted.role}`);
+    }
+    if (record.settlement === "accepted") {
+        return trySettleAcceptedSeatTerminalResult(admitted, authority, scope);
+    }
+    const publish = (roleOutcome, coordinates, entries) => publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries, options);
+    if (record.settlement === "residual") {
+        return settleSealedAcceptedOrToolResidual(admitted, authority, scope, admitted.role, record.residualTool, record.residualScan, publish);
+    }
+    const accept = "sealedAcceptedOnly" in record && record.sealedAcceptedOnly === true
+        ? (roleOutcome) => roleOutcome.role === admitted.role && roleOutcome.kind === "accepted"
+        : undefined;
+    return settleSealedLedgerTerminal(admitted, authority, scope, publish, accept);
 }
-async function settleLawfulCoderTerminalResult(admitted, authority, options = {}, scope) {
-    const ledgerOutcome = await closedLedgerOutcome(admitted, "coder", scope);
-    if (ledgerOutcome === undefined)
-        return undefined;
-    const roleOutcome = ledgerOutcome;
-    const coordinates = coordinatesFromAdmitted(authority, admitted);
-    const entries = await readLawfulSettlementEntries(coordinates.sessionFile) ?? [];
-    const navigator = extractNavigatorFact(entries);
-    const artifacts = await publishCoderArtifacts(admitted, roleOutcome, coordinates, {
-        ...(options.methodProvenance === undefined
-            ? {}
-            : { methodProvenance: options.methodProvenance }),
-    });
-    return withOptionalGateProjection({
-        roleOutcome,
-        navigator,
-        artifacts,
-        runId: admitted.runId,
-    }, coordinates.sessionDirectory, detourGateContext(admitted, scope));
+/**
+ * Try to settle any registered seat. Undefined only for genuine absence.
+ * Session malformation and publication exceptions keep their typed identity.
+ */
+export async function trySettleSeatTerminalResult(admitted, authority, options = {}, scope) {
+    return settleSeat(admitted, authority, scope, options);
 }
-/** Settle a lawful Coder Terminal from the admitted session (shared #106 success interface). */
-export async function settleCoderTerminalResult(admitted, authority, options = {}, scope) {
-    const settled = await settleLawfulCoderTerminalResult(admitted, authority, options, scope);
+/**
+ * Settle any registered seat. Throws when no lawful outcome is present.
+ * Session-read and publication failures retain their typed identity.
+ */
+export async function settleSeatTerminalResult(admitted, authority, options = {}, scope) {
+    const settled = await settleSeat(admitted, authority, scope, options);
     if (settled === undefined) {
-        throw new Error("Coder Role run completed without a lawful typed terminal result");
+        const label = admitted.role.charAt(0).toUpperCase() + admitted.role.slice(1);
+        throw new Error(`${label} Role run completed without a lawful typed terminal result`);
     }
     return settled;
 }
@@ -1909,10 +1914,21 @@ function sessionMessageText(message) {
     return parts.join("\n");
 }
 /**
- * Observe optional Fixer diagnosing-bugs Skill expansions from the session.
- * Availability is always package-bound; invocation is recorded only when observed.
+ * Locations a loaded packaged method may be observed at.
+ * The name is the loaded material; the configured path is the package copy.
  */
-export function extractFixerMethodInvocations(entries, options) {
+export function observedMethodSkillOptions(packageRoot, material) {
+    return {
+        methodProvenance: material.provenance,
+        methodSkillPath: material.skillPath,
+        methodSkillConfiguredPath: resolvePackagedMethodSkillPath(packageRoot, material.name),
+    };
+}
+/**
+ * Observe packaged method Skill expansions from the session.
+ * The skill name is the caller's packaged method; home locations never count.
+ */
+function extractObservedMethodInvocations(entries, options) {
     const observed = [];
     for (const entry of entries) {
         if (entry?.type !== "message")
@@ -1924,7 +1940,7 @@ export function extractFixerMethodInvocations(entries, options) {
         if (text.length === 0)
             continue;
         const hit = observePackagedMethodSkillInvocation(text, {
-            name: "diagnosing-bugs",
+            name: options.name,
             allowedLocations: options.allowedLocations,
         });
         if (hit !== undefined)
@@ -1933,240 +1949,117 @@ export function extractFixerMethodInvocations(entries, options) {
     return Object.freeze(observed);
 }
 /**
- * Publish lawful Fixer success Artifacts on the shared #106 success interface.
- * Evidence records package diagnosis provenance and optional observed invocation.
+ * #836: cost and the auditor's no-receipt facts ride beside the role's
+ * testimony on the current attempt's candidate entry. Absence is omitted,
+ * never invented. Both facts come from that one entry.
  */
-export async function publishFixerArtifacts(admitted, roleOutcome, coordinates, options) {
-    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);
-    if (ledgerOutcome === undefined)
-        return undefined;
-    const roleOutcome = ledgerOutcome;
-    const coordinates = coordinatesFromAdmitted(authority, admitted);
-    const { sessionDirectory, sessionFile } = coordinates;
-    const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-    const navigator = extractNavigatorFact(entries);
-    const methodInvocations = extractFixerMethodInvocations(entries, {
-        allowedLocations: [
-            options.methodSkillPath,
-            options.methodSkillConfiguredPath,
-        ],
-    });
-    const artifacts = await publishFixerArtifacts(admitted, roleOutcome, coordinates, {
-        methodProvenance: options.methodProvenance,
-        methodInvocations,
-    });
-    return withOptionalGateProjection({
-        roleOutcome,
-        navigator,
-        artifacts,
-        runId: admitted.runId,
-    }, sessionDirectory, detourGateContext(admitted, scope));
-}
-/** Settle a lawful Fixer Terminal from the admitted session (shared #106 success interface). */
-export async function settleFixerTerminalResult(admitted, authority, options, scope) {
-    const settled = await settleLawfulFixerTerminalResult(admitted, authority, options, scope);
-    if (settled === undefined) {
-        throw new Error("Fixer Role run completed without a lawful typed terminal result");
-    }
-    return settled;
-}
-export async function publishCollectorArtifacts(admitted, roleOutcome, coordinates) {
-    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);
-    const { sessionDirectory, sessionFile } = coordinates;
-    const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-    const roleOutcome = await sealedLedgerOutcome(admitted, "collector", scope);
-    if (roleOutcome?.role !== "collector" || roleOutcome.kind !== "accepted") {
-        // Bounded to the current attempt so multi-attempt resume timeout/no-output
-        // is not masked by a prior wait-tool residual (#633).
-        const scanStart = currentAttemptStartIndex(entries);
-        for (let index = entries.length - 1; index >= scanStart; index -= 1) {
-            const message = entries[index]?.message;
-            if (message?.role !== "toolResult")
-                continue;
-            const residual = boundErroredToolCandidate(entries, index, message, COLLECTOR_WAIT_TOOL);
-            if (residual === undefined)
-                continue;
-            const candidate = residual.candidate;
-            const details = isRecord(candidate) ? candidate : { candidate };
-            const failed = await settleFailureTerminalResult(admitted, {
-                cause: "output",
-                diagnostic: residual.diagnostic,
-                details,
-            }, authority, scope ?? {});
-            return attachRecordedSubmissions(admitted, failed, scope);
+function extractDoctorCandidateFacts(entries) {
+    const scanStart = currentAttemptStartIndex(entries);
+    for (let i = entries.length - 1; i >= scanStart; i -= 1) {
+        const entry = entries[i];
+        if (entry?.type !== "custom" || entry.customType !== DOCTOR_CANDIDATE_ENTRY_TYPE) {
+            continue;
         }
-        return undefined;
+        const data = entry.data;
+        if (!isRecord(data))
+            return {};
+        return {
+            ...(data.cost === undefined ? {} : { cost: data.cost }),
+            ...(data.auditNoReceipt === undefined ? {} : { auditNoReceipt: data.auditNoReceipt }),
+        };
     }
-    const accepted = roleOutcome;
-    const navigator = extractNavigatorFact(entries);
-    const artifacts = await publishCollectorArtifacts(admitted, accepted, coordinates);
-    return attachRecordedSubmissions(admitted, await withOptionalGateProjection({
-        roleOutcome: accepted,
-        navigator,
-        artifacts,
-        runId: admitted.runId,
-    }, sessionDirectory, detourGateContext(admitted, scope)), scope);
+    return {};
 }
-/** Settle a lawful Collector Terminal from the admitted session. */
-export async function settleCollectorTerminalResult(admitted, authority, scope) {
-    const settled = await settleLawfulCollectorTerminalResult(admitted, authority, scope);
-    if (settled === undefined) {
-        throw new Error("Collector Role run completed without a lawful typed terminal result");
+const EMPTY_ARTIFACT_FACE = { leaves: [] };
+/** Artifact face for one seat. Absent means report/evidence carry only shared leaves. */
+function seatArtifactFace(role) {
+    const record = packagedRoleMetadata(role);
+    if (record !== undefined && "artifactFace" in record && record.artifactFace !== undefined) {
+        return record.artifactFace;
     }
-    return settled;
+    return EMPTY_ARTIFACT_FACE;
 }
-/** Try to settle a lawful Collector Terminal; undefined only for genuine absence. */
-export async function trySettleCollectorTerminalResult(admitted, authority, scope) {
-    return settleLawfulCollectorTerminalResult(admitted, authority, scope);
+function readAdmittedPath(source, path) {
+    let current = source;
+    for (const part of path.split(".")) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
 }
-/**
- * #836: runtime cost is a machine fact recorded beside the role's original
- * testimony (`ak_doctor_audit_candidate` custom entry), never merged into the
- * accepted payload itself. Absence (no candidate entry, or entry without a
- * cost sibling) reads as undefined — never invented.
- */
-function extractDoctorCandidateCostFact(entries) {
-    const scanStart = currentAttemptStartIndex(entries);
-    for (let i = entries.length - 1; i >= scanStart; i -= 1) {
-        const entry = entries[i];
-        if (entry?.type === "custom" && entry.customType === DOCTOR_CANDIDATE_ENTRY_TYPE) {
-            const data = entry.data;
-            return isRecord(data) ? data.cost : undefined;
+function evidenceLeaves(admitted, leaves) {
+    const evidence = {};
+    for (const leaf of leaves) {
+        if (leaf.callerProvenance === true) {
+            if (!admitted.instructionEmpty)
+                evidence[leaf.key] = admitted.instruction;
+            continue;
         }
+        const value = readAdmittedPath(admitted, leaf.from ?? leaf.key);
+        if (value === undefined && leaf.omitUndefined === true)
+            continue;
+        evidence[leaf.key] = leaf.copyArray === true && Array.isArray(value) ? [...value] : value;
     }
-    return undefined;
+    return evidence;
 }
-/**
- * #836: the auditor's own no-receipt lifecycle facts are a machine fact about
- * the audit leg, recorded beside (never merged into) the role's accepted
- * testimony. Absence reads as undefined — never invented.
- */
-function extractDoctorCandidateAuditNoReceiptFact(entries) {
-    const scanStart = currentAttemptStartIndex(entries);
-    for (let i = entries.length - 1; i >= scanStart; i -= 1) {
-        const entry = entries[i];
-        if (entry?.type === "custom" && entry.customType === DOCTOR_CANDIDATE_ENTRY_TYPE) {
-            const data = entry.data;
-            return isRecord(data) ? data.auditNoReceipt : undefined;
-        }
+function doctorReportFacts(face, roleOutcome, entries) {
+    if (face.doctorReportFacts !== true || roleOutcome.kind === "audit_escalation")
+        return {};
+    const facts = extractDoctorCandidateFacts(entries);
+    return {
+        ...(facts.cost === undefined ? {} : { cost: facts.cost }),
+        ...(facts.auditNoReceipt === undefined ? {} : { auditNoReceipt: facts.auditNoReceipt }),
+    };
+}
+function observedMethodTail(face, entries, options) {
+    if (face.method === undefined)
+        return {};
+    if (face.method === "optional") {
+        return options.methodProvenance === undefined
+            ? {}
+            : { methodProvenance: options.methodProvenance };
     }
-    return undefined;
+    if (options.methodProvenance === undefined
+        || options.methodSkillPath === undefined
+        || options.methodSkillConfiguredPath === undefined) {
+        throw new Error("observed method publication is missing packaged method coordinates");
+    }
+    const methodInvocations = extractObservedMethodInvocations(entries, {
+        name: options.methodProvenance.name,
+        allowedLocations: [options.methodSkillPath, options.methodSkillConfiguredPath],
+    });
+    return {
+        methodProvenance: options.methodProvenance,
+        methodInvocationObserved: methodInvocations.length > 0,
+        methodInvocations,
+    };
 }
-export async function publishDoctorArtifacts(admitted, roleOutcome, coordinates, options = {}) {
+async function publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries, options = {}) {
+    const face = seatArtifactFace(admitted.role);
+    const phase = face.reportPhase === true
+        ? { phase: readAdmittedPath(admitted, "phase") }
+        : {};
     return publishAcceptedTerminalArtifacts(admitted, roleOutcome, coordinates, {
         report: {
-            role: "doctor",
+            role: admitted.role,
             runId: admitted.runId,
+            ...phase,
             outcome: roleOutcome,
-            ...(options.cost === undefined ? {} : { cost: options.cost }),
-            ...(options.auditNoReceipt === undefined
-                ? {}
-                : { auditNoReceipt: options.auditNoReceipt }),
+            ...doctorReportFacts(face, roleOutcome, entries),
         },
         evidence: {
             runId: admitted.runId,
-            role: "doctor",
-            issueNumber: admitted.issueNumber,
-            caseRunsPath: admitted.caseRunsPath,
-            caseIdentity: admitted.caseIdentity,
+            ...(face.evidenceRole === true ? { role: admitted.role } : {}),
+            ...evidenceLeaves(admitted, face.leaves),
             sessionDirectory: coordinates.sessionDirectory,
             sessionFile: coordinates.sessionFile,
             admittedRequestPath: admitted.admittedRequestPath,
             attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
+            ...observedMethodTail(face, entries, options),
         },
     });
 }
-async function settleLawfulDoctorTerminalResult(admitted, authority, scope) {
-    const sealed = await sealedLedgerOutcome(admitted, "doctor", scope);
-    const coordinates = coordinatesFromAdmitted(authority, admitted);
-    const { sessionDirectory, sessionFile } = coordinates;
-    const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-    if (sealed === undefined)
-        return undefined;
-    if (sealed.kind === "audit_escalation") {
-        const artifacts = await publishDoctorArtifacts(admitted, sealed, coordinates);
-        return withOptionalGateProjection({
-            roleOutcome: sealed,
-            navigator: extractNavigatorFact(entries),
-            artifacts,
-            runId: admitted.runId,
-        }, sessionDirectory, detourGateContext(admitted, scope));
-    }
-    const roleOutcome = sealed;
-    const navigator = extractNavigatorFact(entries);
-    const cost = extractDoctorCandidateCostFact(entries);
-    const auditNoReceipt = extractDoctorCandidateAuditNoReceiptFact(entries);
-    const artifacts = await publishDoctorArtifacts(admitted, roleOutcome, coordinates, {
-        ...(cost === undefined ? {} : { cost }),
-        ...(auditNoReceipt === undefined ? {} : { auditNoReceipt }),
-    });
-    return withOptionalGateProjection({
-        roleOutcome,
-        navigator,
-        artifacts,
-        runId: admitted.runId,
-    }, sessionDirectory, detourGateContext(admitted, scope));
-}
-/** Settle a lawful Doctor Terminal from the admitted session. */
-export async function settleDoctorTerminalResult(admitted, authority, scope) {
-    const settled = await settleLawfulDoctorTerminalResult(admitted, authority, scope);
-    if (settled === undefined) {
-        throw new Error("Doctor Role run completed without a lawful typed terminal result");
-    }
-    return settled;
-}
-/** Try to settle a lawful Doctor Terminal; undefined only for genuine absence. */
-export async function trySettleDoctorTerminalResult(admitted, authority, scope) {
-    return settleLawfulDoctorTerminalResult(admitted, authority, scope);
-}
 /** Latest top-level user message index; 0 when the session has none (initial attempt). */
 function currentAttemptStartIndex(entries) {
     for (let i = entries.length - 1; i >= 0; i -= 1) {
@@ -2177,25 +2070,6 @@ 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;
@@ -2230,10 +2104,10 @@ async function settleLawfulSeatAcceptedTerminalResult(admitted, authority, spec,
             residual = boundErroredToolCandidate(entries, index, message, spec.toolName);
         }
     }
-    const roleOutcome = await closedLedgerOutcome(admitted, spec.role, scope);
+    const roleOutcome = await sealedLedgerOutcome(admitted, spec.role, scope);
     if (roleOutcome !== undefined && (thisAttemptHasSeatSuccess || residual === undefined)) {
         const navigator = extractNavigatorFact(entries);
-        const artifacts = await publishSeatAcceptedArtifacts(admitted, roleOutcome, coordinates);
+        const artifacts = await publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries);
         return withSubmissions(await withOptionalGateProjection({
             roleOutcome,
             navigator,
@@ -2254,70 +2128,36 @@ async function settleLawfulSeatAcceptedTerminalResult(admitted, authority, spec,
     }
     return undefined;
 }
-async function settleLawfulNotaryTerminalResult(admitted, authority, scope) {
-    // #757: default sealed pass-through — no projectAccepted identity wrapper.
-    return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "notary",
-        toolName: NOTARY_OUTPUT_TOOL_NAME,
-    }, scope);
-}
-/** Settle a lawful Notary Terminal from the admitted session. */
-export async function settleNotaryTerminalResult(admitted, authority, scope) {
-    const settled = await settleLawfulNotaryTerminalResult(admitted, authority, scope);
-    if (settled === undefined) {
-        throw new Error("Notary Role run completed without a lawful typed terminal result");
+/** Accepted-tool seats: one scan, tool name from the composition-root record. */
+export async function trySettleAcceptedSeatTerminalResult(admitted, authority, scope) {
+    const toolName = packagedRoleAcceptedOutputTool(admitted.role);
+    if (toolName === undefined) {
+        throw new Error(`accepted-seat settlement is not declared for ${admitted.role}`);
     }
-    return settled;
-}
-/** Try to settle a lawful Notary Terminal; undefined only for genuine absence. */
-export async function trySettleNotaryTerminalResult(admitted, authority, scope) {
-    return settleLawfulNotaryTerminalResult(admitted, authority, scope);
-}
-async function settleLawfulCountersignTerminalResult(admitted, authority, scope) {
-    return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "countersign",
-        toolName: COUNTERSIGN_OUTPUT_TOOL_NAME,
-    }, scope);
-}
-/** Settle a lawful Countersign Terminal from the admitted session. */
-export async function settleCountersignTerminalResult(admitted, authority, scope) {
-    const settled = await settleLawfulCountersignTerminalResult(admitted, authority, scope);
-    if (settled === undefined) {
-        throw new Error("Countersign Role run completed without a lawful typed terminal result");
-    }
-    return settled;
-}
-/** Try to settle a lawful Countersign Terminal; undefined only for genuine absence. */
-export async function trySettleCountersignTerminalResult(admitted, authority, scope) {
-    return settleLawfulCountersignTerminalResult(admitted, authority, scope);
-}
-async function settleLawfulGleanerLeftTerminalResult(admitted, authority, scope) {
-    return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "gleaner-left",
-        toolName: GLEANER_LEFT_OUTPUT_TOOL_NAME,
+    const settled = await settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
+        role: admitted.role,
+        toolName,
     }, scope);
-}
-/** Settle a lawful Gleaner-Left Terminal from the admitted session. */
-export async function settleGleanerLeftTerminalResult(admitted, authority, scope) {
-    const settled = await settleLawfulGleanerLeftTerminalResult(admitted, authority, scope);
-    if (settled === undefined) {
-        throw new Error("Gleaner-Left Role run completed without a lawful typed terminal result");
+    const record = packagedRoleMetadata(admitted.role);
+    if (settled === undefined
+        || record === undefined
+        || !("projectCountersignTerminal" in record)
+        || record.projectCountersignTerminal !== true) {
+        return settled;
     }
-    return settled;
+    return applySecretariatCountersignTerminal(admitted, authority, settled);
 }
-/** Try to settle a lawful Gleaner-Left Terminal; undefined only for genuine absence. */
-export async function trySettleGleanerLeftTerminalResult(admitted, authority, scope) {
-    return settleLawfulGleanerLeftTerminalResult(admitted, authority, scope);
-}
-async function settleLawfulDiaristTerminalResult(admitted, authority, scope) {
-    return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "diarist",
-        toolName: DIARIST_OUTPUT_TOOL_NAME,
-    }, scope);
-}
-/** Try to settle a lawful Diarist Terminal; undefined only for genuine absence. */
-export async function trySettleDiaristTerminalResult(admitted, authority, scope) {
-    return settleLawfulDiaristTerminalResult(admitted, authority, scope);
+/** One settlement dispatch. The registry `settlement` leaf selects the path. */
+export async function trySettlePublicSeat(admitted, authority, scope, material, packageRoot) {
+    const face = seatArtifactFace(admitted.role);
+    if (face.method === "observed" && material === undefined)
+        return undefined;
+    const options = face.method === "observed" && material !== undefined
+        ? observedMethodSkillOptions(packageRoot, material)
+        : face.method === "optional" && material !== undefined
+            ? { methodProvenance: material.provenance }
+            : {};
+    return settleSeat(admitted, authority, scope, options);
 }
 /**
  * #969 seat projection sole authority: 给事中 terminal (署|上呈) booked as a
@@ -2337,7 +2177,7 @@ function countersignTerminalFromEntries(entries) {
         const data = entry.data !== null && typeof entry.data === "object" && !Array.isArray(entry.data)
             ? entry.data
             : undefined;
-        if (data?.officer !== "countersign")
+        if (data === undefined || !packagedDurableOfficerEntry(data.officer))
             continue;
         if (data.receipt === undefined)
             continue;
@@ -2382,13 +2222,7 @@ function acceptedSecretariatDefinesOfficerProjection(roleOutcome) {
     }
     return false;
 }
-async function settleLawfulSecretariatTerminalResult(admitted, authority, scope) {
-    const settled = await settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "secretariat",
-        toolName: SECRETARIAT_OUTPUT_TOOL_NAME,
-    }, scope);
-    if (settled === undefined)
-        return undefined;
+async function applySecretariatCountersignTerminal(admitted, authority, settled) {
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     const entries = await readLawfulSettlementEntries(coordinates.sessionFile) ?? [];
     const officer = countersignTerminalFromEntries(entries);
@@ -2418,254 +2252,6 @@ async function settleLawfulSecretariatTerminalResult(admitted, authority, scope)
     }
     return settled;
 }
-/** Try to settle a lawful Secretariat Terminal; undefined only for genuine absence. */
-export async function trySettleSecretariatTerminalResult(admitted, authority, scope) {
-    return settleLawfulSecretariatTerminalResult(admitted, authority, scope);
-}
-async function settleLawfulInspectorTerminalResult(admitted, authority, scope) {
-    return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "inspector",
-        toolName: INSPECTOR_OUTPUT_TOOL_NAME,
-    }, scope);
-}
-export async function trySettleInspectorTerminalResult(admitted, authority, scope) {
-    return settleLawfulInspectorTerminalResult(admitted, authority, scope);
-}
-async function settleLawfulGatekeeperTerminalResult(admitted, authority, scope) {
-    return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "gatekeeper",
-        toolName: GATEKEEPER_OUTPUT_TOOL_NAME,
-    }, scope);
-}
-/** Try to settle a lawful Gatekeeper Terminal; undefined only for genuine absence. */
-export async function trySettleGatekeeperTerminalResult(admitted, authority, scope) {
-    return settleLawfulGatekeeperTerminalResult(admitted, authority, scope);
-}
-async function settleLawfulNavigatorTerminalResult(admitted, authority, scope) {
-    return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "navigator",
-        toolName: NAVIGATOR_OUTPUT_TOOL_NAME,
-    }, scope);
-}
-/** Try to settle a lawful Navigator Terminal; undefined only for genuine absence. */
-export async function trySettleNavigatorTerminalResult(admitted, authority, scope) {
-    return settleLawfulNavigatorTerminalResult(admitted, authority, scope);
-}
-async function settleLawfulAuditorTerminalResult(admitted, authority, scope) {
-    return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
-        role: "auditor",
-        toolName: AUDITOR_OUTPUT_TOOL_NAME,
-    }, scope);
-}
-export async function trySettleAuditorTerminalResult(admitted, authority, scope) {
-    return settleLawfulAuditorTerminalResult(admitted, authority, scope);
-}
-/** Try to settle a lawful Coder Terminal; undefined only for genuine absence. */
-export async function trySettleCoderTerminalResult(admitted, authority, options = {}, scope) {
-    return settleLawfulCoderTerminalResult(admitted, authority, options, scope);
-}
-/** Try to settle a lawful Fixer Terminal; undefined only for genuine absence. */
-export async function trySettleFixerTerminalResult(admitted, authority, options, scope) {
-    return settleLawfulFixerTerminalResult(admitted, authority, options, scope);
-}
-/**
- * Observe forced Reviewer ak-cross-m-review Skill expansions from the session.
- * Expansion evidence is package-path only; ambient home locations never count.
- */
-export function extractReviewerMethodInvocations(entries, options) {
-    const observed = [];
-    for (const entry of entries) {
-        if (entry?.type !== "message")
-            continue;
-        const message = entry.message;
-        if (message?.role !== "user")
-            continue;
-        const text = sessionMessageText(message);
-        if (text.length === 0)
-            continue;
-        const hit = observePackagedMethodSkillInvocation(text, {
-            name: "ak-cross-m-review",
-            allowedLocations: options.allowedLocations,
-        });
-        if (hit !== undefined)
-            observed.push(hit);
-    }
-    return Object.freeze(observed);
-}
-/**
- * Publish lawful Reviewer success Artifacts on the shared #106 success interface.
- * Evidence records package ak-cross-m-review provenance and typed expansion
- * observation without ambient home Skill paths.
- */
-export async function publishReviewerArtifacts(admitted, roleOutcome, coordinates, options) {
-    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);
-    if (sealed?.role !== "reviewer" || sealed.kind !== "accepted")
-        return undefined;
-    const coordinates = coordinatesFromAdmitted(authority, admitted);
-    const { sessionDirectory, sessionFile } = coordinates;
-    const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-    const roleOutcome = sealed;
-    const navigator = extractNavigatorFact(entries);
-    const methodInvocations = extractReviewerMethodInvocations(entries, {
-        allowedLocations: [
-            options.methodSkillPath,
-            options.methodSkillConfiguredPath,
-        ],
-    });
-    const artifacts = await publishReviewerArtifacts(admitted, roleOutcome, coordinates, {
-        methodProvenance: options.methodProvenance,
-        methodInvocations,
-    });
-    return withOptionalGateProjection({
-        roleOutcome,
-        navigator,
-        artifacts,
-        runId: admitted.runId,
-    }, sessionDirectory, detourGateContext(admitted, scope));
-}
-/** Settle a lawful Reviewer Terminal from the admitted session (shared #106 success interface). */
-export async function settleReviewerTerminalResult(admitted, authority, options, scope) {
-    const settled = await settleLawfulReviewerTerminalResult(admitted, authority, options, scope);
-    if (settled === undefined) {
-        throw new Error("Reviewer Role run completed without a lawful typed terminal result");
-    }
-    return settled;
-}
-/** Try to settle a lawful Reviewer Terminal; undefined only for genuine absence. */
-export async function trySettleReviewerTerminalResult(admitted, authority, options, scope) {
-    return settleLawfulReviewerTerminalResult(admitted, authority, options, scope);
-}
-/**
- * Observe forced Merger resolving-merge-conflicts Skill expansions from the session.
- * Expansion evidence is package-path only; ambient home locations never count.
- */
-export function extractMergerMethodInvocations(entries, options) {
-    const observed = [];
-    for (const entry of entries) {
-        if (entry?.type !== "message")
-            continue;
-        const message = entry.message;
-        if (message?.role !== "user")
-            continue;
-        const text = sessionMessageText(message);
-        if (text.length === 0)
-            continue;
-        const hit = observePackagedMethodSkillInvocation(text, {
-            name: "resolving-merge-conflicts",
-            allowedLocations: options.allowedLocations,
-        });
-        if (hit !== undefined)
-            observed.push(hit);
-    }
-    return Object.freeze(observed);
-}
-/**
- * Publish lawful Merger success Artifacts on the shared #106 success interface.
- * Evidence records package method provenance, forced expansion observation, and
- * adapter-derived mechanical envelope facts without ambient home Skill paths.
- */
-export async function publishMergerArtifacts(admitted, roleOutcome, coordinates, options) {
-    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);
-    const { sessionDirectory, sessionFile } = coordinates;
-    const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-    const roleOutcome = await sealedLedgerOutcome(admitted, "merger", scope);
-    if (roleOutcome?.role !== "merger" || roleOutcome.kind !== "accepted") {
-        // #836: non-sole-round barrier deleted; residual path is host/session only.
-        for (let index = entries.length - 1; index >= 0; index -= 1) {
-            const message = entries[index]?.message;
-            if (message?.role !== "toolResult")
-                continue;
-            const residual = boundErroredToolCandidate(entries, index, message, MERGER_OUTPUT_TOOL_NAME);
-            if (residual === undefined)
-                continue;
-            const candidate = residual.candidate;
-            const details = isRecord(candidate) ? candidate : { candidate };
-            const failed = await settleFailureTerminalResult(admitted, {
-                cause: "output",
-                diagnostic: residual.diagnostic,
-                details,
-            }, authority, scope ?? {});
-            return attachRecordedSubmissions(admitted, failed, scope);
-        }
-        return undefined;
-    }
-    const accepted = roleOutcome;
-    const navigator = extractNavigatorFact(entries);
-    const methodInvocations = extractMergerMethodInvocations(entries, {
-        allowedLocations: [options.methodSkillPath, options.methodSkillConfiguredPath],
-    });
-    const artifacts = await publishMergerArtifacts(admitted, accepted, coordinates, {
-        methodProvenance: options.methodProvenance,
-        methodInvocations,
-    });
-    return attachRecordedSubmissions(admitted, await withOptionalGateProjection({
-        roleOutcome: accepted,
-        navigator,
-        artifacts,
-        runId: admitted.runId,
-    }, sessionDirectory, detourGateContext(admitted, scope)), scope);
-}
-/** Settle a lawful Merger Terminal from the admitted session (shared #106 success interface). */
-export async function settleMergerTerminalResult(admitted, authority, options, scope) {
-    const settled = await settleLawfulMergerTerminalResult(admitted, authority, options, scope);
-    if (settled === undefined) {
-        throw new Error("Merger Role run completed without a lawful typed terminal result");
-    }
-    return settled;
-}
-/** Try to settle a lawful Merger Terminal; undefined only for genuine absence. */
-export async function trySettleMergerTerminalResult(admitted, authority, options, scope) {
-    return settleLawfulMergerTerminalResult(admitted, authority, options, scope);
-}
 function publicationAttemptFromError(path, error) {
     if (error instanceof Error) {
         const identity = {
@@ -2871,7 +2457,7 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
                     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") {
+                    if (packagedProjectsTargetBindRejection(admitted.role)) {
                         const bindRejection = extractCollectorTargetBindRejection(entries.slice(attemptStart));
                         if (bindRejection !== undefined) {
                             decisiveFacts = {