@akagilnc/pi-workflow-roles 0.1.4239 → 0.1.4259

package/dist/public-cli/post-admission.js

@@ -6,7 +6,7 @@
  * Role runners supply only turn request projection and narrow settlement adapters.
  */
 import { randomUUID } from "node:crypto";
-import { readFile, writeFile } from "node:fs/promises";
+import { writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
 import { buildResumeContinuationPrompt, RESUME_TRANSPORT_ENVELOPE, } from "./run-lifecycle.js";
 import { CliUsageError } from "./cli-errors.js";
@@ -39,6 +39,7 @@ function appendContinuationSection(continuation, section) {
 function isStationChildOfficerDialogue(role, env) {
     return env.stationChild === true && isOfficerReviewSeat(role);
 }
+import { mintEngineDetourInvocationScope, readInvocationSelectedHost, withEngineDetourInvocationScope, } from "../engine-detour-usage.js";
 import { projectHostTransitionPriorNative } from "../host-transition-prior-native.js";
 import { missingCredentialPreDispatchFailure, postRunMissingCredentialFailure, } from "./public-run-credentials.js";
 import { acquireRunWriterLease, clearCurrentCourt, clearTypedProviderHttpObservation, describeErrorIdentity, markRunRunning, readCurrentCourt, recordCurrentCourt, renderResumeCommand, RunWriterLeaseHeldError, } from "./run-lifecycle.js";
@@ -106,18 +107,6 @@ async function recordBestEffortPostDispatchDiagnostic(admitted, env, diagnostic,
         }
     }
 }
-/** Previous main-session host recorded on invocation.json, if any. */
-async function readInvocationHost(runDirectory) {
-    try {
-        const raw = JSON.parse(await readFile(join(runDirectory, "invocation.json"), "utf8"));
-        return typeof raw.host === "string" && raw.host.trim() !== "" ? raw.host : undefined;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-}
 /**
  * Factory-seat resume method-material face (#833): one authority for
  * load → adapters / controlled-failure short-circuit. Seats only declare
@@ -196,9 +185,15 @@ export async function presentControlledFailure(admitted, failureInput, adapters,
     if (persistRunState && !failureInput.skipRunStateWrite) {
         await persistReturnedRunState(admitted, authority);
     }
-    const terminal = await attachRecordedSubmissions(admitted, await settleFailureTerminalResult(admitted, failure, authority, resumable
-        ? { resume: { command: renderResumeCommand(admitted.runId) } }
-        : {}));
+    const terminal = await attachRecordedSubmissions(admitted, await settleFailureTerminalResult(admitted, failure, authority, {
+        ...(resumable
+            ? { resume: { command: renderResumeCommand(admitted.runId) } }
+            : {}),
+        ...(failureInput.invocationScopeId === undefined ||
+            failureInput.invocationScopeId.length === 0
+            ? {}
+            : { invocationScopeId: failureInput.invocationScopeId }),
+    }));
     presentFailureTerminal(terminal, io);
     return {
         exitCode: exitCodeForTerminalOutcome(terminal.roleOutcome),
@@ -282,12 +277,12 @@ export async function dispatchPostAdmissionTurn(input) {
                 return result;
             }
             return {
-                ...(await presentControlledFailure(admitted, {
+                ...(await presentControlledFailure(admitted, withEngineDetourInvocationScope({
                     timedOut: false,
                     code: null,
                     stderr: "",
                     thrown: error,
-                }, adapters, env.principalAuthority, io, persistRunState)),
+                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState)),
                 ...(result.turnDispatched === true ? { turnDispatched: true } : {}),
                 ...(result.skipAutoResume === true ? { skipAutoResume: true } : {}),
                 ...deferredPersist,
@@ -298,7 +293,7 @@ export async function dispatchPostAdmissionTurn(input) {
         const missingCredential = missingCredentialPreDispatchFailure(env.model, env.credentials);
         if (missingCredential !== undefined) {
             return {
-                ...(await presentControlledFailure(admitted, missingCredential, adapters, env.principalAuthority, io, persistRunState)),
+                ...(await presentControlledFailure(admitted, withEngineDetourInvocationScope(missingCredential, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState)),
                 ...deferredPersist,
             };
         }
@@ -312,7 +307,7 @@ export async function dispatchPostAdmissionTurn(input) {
             : env.principalAuthority.decode(admitted.principal);
         let hostTransition;
         try {
-            previousHost = await readInvocationHost(admitted.runDirectory);
+            previousHost = readInvocationSelectedHost(admitted.runDirectory);
             hostTransition =
                 previousHost !== undefined && liveHost !== undefined && principalCoordinates !== undefined
                     ? await projectHostTransitionPriorNative({
@@ -325,12 +320,12 @@ export async function dispatchPostAdmissionTurn(input) {
         catch (error) {
             // prior-native IO is on the public one-shot path — controlled failure, not bare throw.
             return {
-                ...(await presentControlledFailure(admitted, {
+                ...(await presentControlledFailure(admitted, withEngineDetourInvocationScope({
                     timedOut: false,
                     code: null,
                     stderr: "",
                     thrown: error,
-                }, adapters, env.principalAuthority, io, persistRunState)),
+                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState)),
                 ...deferredPersist,
             };
         }
@@ -342,7 +337,7 @@ export async function dispatchPostAdmissionTurn(input) {
         // executeTurn — not merely past beforeDispatch (#840 r9 判词 class 2). Any
         // pre-turn retry (beforeDispatch, dossier projection, continuation
         // assembly) must still see the prior invocation host on its next attempt;
-        // committing env.host earlier would make readInvocationHost read back the
+        // committing env.host earlier would make readInvocationSelectedHost read back the
         // new host on the retry and silently drop hostTransition.
         // Failures settle the run (presentControlledFailure); they must not leave it
         // permanently running. Call-local auto-resume retries this hook until it
@@ -353,12 +348,12 @@ export async function dispatchPostAdmissionTurn(input) {
                 await adapters.beforeDispatch(admitted, lease);
             }
             catch (error) {
-                const settled = (await presentControlledFailure(admitted, {
+                const settled = (await presentControlledFailure(admitted, withEngineDetourInvocationScope({
                     timedOut: false,
                     code: null,
                     stderr: "",
                     thrown: error,
-                }, adapters, env.principalAuthority, io, persistRunState));
+                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState));
                 if (error instanceof StationChildExhaustedError) {
                     return { ...settled, skipAutoResume: true, ...deferredPersist };
                 }
@@ -378,6 +373,11 @@ export async function dispatchPostAdmissionTurn(input) {
         if (hostTransition !== undefined) {
             turnRequest = { ...turnRequest, hostTransition };
         }
+        // Selected host axis rides the shared Host envelope for in-turn tools
+        // (detour usage ledger) — never a pre-spawn invocation.json reread.
+        if (typeof liveHost === "string" && liveHost.trim() !== "") {
+            turnRequest = { ...turnRequest, host: liveHost.trim() };
+        }
         if (isStationChildOfficerDialogue(admitted.role, env)) {
             // 0081 non-body face: freeze pointer section under run/attachments/.
             // Peer dialogue continuation.prompt stays parent payload only — the seat
@@ -408,17 +408,20 @@ export async function dispatchPostAdmissionTurn(input) {
         // immediately before the turn actually starts, after every retryable
         // pre-turn step above has succeeded on this attempt (#840 r9 判词 class 2).
         await markRunRunning(admitted.runDirectory, env.model, effectiveEngine, env.host, env.engineModel);
+        // #537 invocation scope is bound once at the public-entry boundary
+        // (runPostAdmissionResumable / ManualResume / station-child), not here:
+        // auto-resume re-enters this dispatch and must reuse the same scope.
         let result;
         try {
             result = await env.roleTurnHost.executeTurn(turnRequest);
         }
         catch (error) {
-            const settled = await settleAfterTurnStarted(admitted, {
+            const settled = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
                 timedOut: false,
                 code: null,
                 stderr: "",
                 thrown: error,
-            }, adapters, env.principalAuthority, io, persistRunState);
+            }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
             return await finishAfterTurn({ ...settled, turnDispatched: true, ...deferredPersist });
         }
         // `result.stderr` stays live in memory for the real classification below
@@ -462,9 +465,18 @@ export async function dispatchPostAdmissionTurn(input) {
             // wrong, becomes the reported failure itself (#836).
             await recordBestEffortPostDispatchDiagnostic(admitted, env, `stderr.log write failed (best-effort continue): ${describeErrorIdentity(error)}`, io);
         }
-        const courtScope = request.courtAttemptId === undefined || request.courtAttemptId.length === 0
+        const courtScope = (request.courtAttemptId === undefined || request.courtAttemptId.length === 0) &&
+            (request.invocationScopeId === undefined || request.invocationScopeId.length === 0)
             ? undefined
-            : { courtAttemptId: request.courtAttemptId };
+            : {
+                ...(request.courtAttemptId === undefined || request.courtAttemptId.length === 0
+                    ? {}
+                    : { courtAttemptId: request.courtAttemptId }),
+                ...(request.invocationScopeId === undefined ||
+                    request.invocationScopeId.length === 0
+                    ? {}
+                    : { invocationScopeId: request.invocationScopeId }),
+            };
         // Single complete boundary (#840 r9 判词 class 1): resolving the
         // host/runner failure facts, trySettle, its shouldPresent gate, and the
         // accepted-settlement cleanup all settle through this one catch — a
@@ -580,12 +592,12 @@ export async function dispatchPostAdmissionTurn(input) {
         catch (error) {
             // Settle (or its shouldPresent gate, or the failure-fact resolution
             // above) throw is a real failure fact — never swallow into undefined.
-            const settledFailure = await settleAfterTurnStarted(admitted, {
+            const settledFailure = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
                 timedOut: false,
                 code: result.code,
                 stderr: result.stderr,
                 thrown: error,
-            }, adapters, env.principalAuthority, io, persistRunState);
+            }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
             return await finishAfterTurn({ ...settledFailure, turnDispatched: true, ...deferredPersist });
         }
         if (settledOutcome !== undefined) {
@@ -604,13 +616,13 @@ export async function dispatchPostAdmissionTurn(input) {
                     // at all. skipRunStateWrite: the write that just threw is the same
                     // write presentControlledFailure would otherwise retry — don't
                     // call a known-failing operation twice.
-                    const failed = await settleAfterTurnStarted(admitted, {
+                    const failed = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
                         timedOut: false,
                         code: null,
                         stderr: "",
                         thrown: error,
                         skipRunStateWrite: true,
-                    }, adapters, env.principalAuthority, io, persistRunState);
+                    }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
                     return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
                 }
             }
@@ -624,7 +636,7 @@ export async function dispatchPostAdmissionTurn(input) {
             const stderrLogWriteDetails = stderrLogWriteFailure === undefined
                 ? undefined
                 : { stderrLogWriteFailure: describeCaughtError(stderrLogWriteFailure) };
-            const failed = await settleAfterTurnStarted(admitted, {
+            const failed = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
                 timedOut: result.timedOut,
                 code: result.code,
                 stderr: result.stderr,
@@ -642,22 +654,22 @@ export async function dispatchPostAdmissionTurn(input) {
                             },
                         }
                         : { knownDetails: stderrLogWriteDetails }),
-            }, adapters, env.principalAuthority, io, persistRunState);
+            }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
             return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
         }
         // Nothing else was wrong, but the durable stderr mirror itself failed to
         // write — that is the real (infrastructure) problem in this case, not a
         // lawful absence of a receipt. Honest and loud, not silently no_receipt.
         if (stderrLogWriteFailure !== undefined) {
-            const failed = await settleAfterTurnStarted(admitted, {
+            const failed = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
                 timedOut: false,
                 code: result.code,
                 stderr: result.stderr,
                 thrown: stderrLogWriteFailure,
-            }, adapters, env.principalAuthority, io, persistRunState);
+            }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
             return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
         }
-        const noReceipt = await attachRecordedSubmissions(admitted, await settleHostEndedNoReceipt(admitted, env.principalAuthority), courtScope);
+        const noReceipt = await attachRecordedSubmissions(admitted, await settleHostEndedNoReceipt(admitted, env.principalAuthority, courtScope), courtScope);
         if (persistRunState) {
             try {
                 await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
@@ -668,13 +680,13 @@ export async function dispatchPostAdmissionTurn(input) {
                 // the real failure surfaces loudly instead of escaping uncaught to
                 // auto-resume's dispatch-retry path with no recorded submissions.
                 // skipRunStateWrite: don't retry the write that just threw.
-                const failed = await settleAfterTurnStarted(admitted, {
+                const failed = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
                     timedOut: false,
                     code: null,
                     stderr: "",
                     thrown: error,
                     skipRunStateWrite: true,
-                }, adapters, env.principalAuthority, io, persistRunState);
+                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
                 return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
             }
         }
@@ -941,6 +953,12 @@ export async function runPostAdmissionSeatResume(input) {
         if (input.env.stationChild === true) {
             let firstTurn;
             const stationAdapters = withOnceSuccessfulBeforeDispatch(adapters);
+            // One public call → one detour scope across in-place auto-resume dispatches.
+            const invocationScopeId = mintEngineDetourInvocationScope({
+                ...(input.effectiveEngine === undefined
+                    ? {}
+                    : { effectiveEngine: input.effectiveEngine }),
+            });
             return await runWithAutoResumeLoop({
                 admitted: loaded.admitted,
                 principalAuthority: input.env.principalAuthority,
@@ -974,7 +992,7 @@ export async function runPostAdmissionSeatResume(input) {
                                 },
                             };
                         }
-                        const turnRequest = await buildRequestAfterLease();
+                        const turnRequest = withEngineDetourInvocationScope(await buildRequestAfterLease(), invocationScopeId);
                         firstTurn = turnRequest;
                         return turnRequest;
                     },
@@ -1058,6 +1076,12 @@ export async function runPostAdmissionOneShot(input) {
 export async function runPostAdmissionResumable(input) {
     const { admitted, env, io, buildInitialRequest, buildResumeRequest, effectiveEngine } = input;
     const adapters = withOnceSuccessfulBeforeDispatch(input.adapters);
+    // One public call → one detour scope across in-place auto-resume dispatches.
+    const invocationScopeId = mintEngineDetourInvocationScope({
+        ...(effectiveEngine === undefined ? {} : { effectiveEngine }),
+    });
+    const buildScopedInitial = () => withEngineDetourInvocationScope(buildInitialRequest(), invocationScopeId);
+    const buildScopedResume = () => withEngineDetourInvocationScope(buildResumeRequest(), invocationScopeId);
     return runWithAutoResumeLoop({
         admitted,
         principalAuthority: env.principalAuthority,
@@ -1065,8 +1089,8 @@ export async function runPostAdmissionResumable(input) {
         io,
         sessionAppender: env.sessionAppender,
         autoResumeLimit: env.autoResumeLimit,
-        buildInitialPayload: buildInitialRequest,
-        buildResumePayload: buildResumeRequest,
+        buildInitialPayload: buildScopedInitial,
+        buildResumePayload: buildScopedResume,
         dispatch: async (request, lease, _isFirst, attemptIo) => {
             const result = await dispatchPostAdmissionTurn({
                 admitted,
@@ -1124,6 +1148,10 @@ export async function runPostAdmissionManualResume(input) {
         }
         throw error;
     }
+    // Explicit public resume is a new counting unit — mint once for this call.
+    const invocationScopeId = mintEngineDetourInvocationScope({
+        ...(effectiveEngine === undefined ? {} : { effectiveEngine }),
+    });
     const result = await dispatchAfterWriterLease({
         lease,
         build: async () => {
@@ -1133,6 +1161,7 @@ export async function runPostAdmissionManualResume(input) {
                 }
                 request = await buildRequestAfterLease();
             }
+            request = withEngineDetourInvocationScope(request, invocationScopeId);
             return request;
         },
         dispatch: (turnRequest) => dispatchPostAdmissionTurn({

package/dist/public-cli/settlement.js

@@ -21,6 +21,7 @@ import { AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE, AUDITOR_PARENT_ATTEMPT_BINDING_E
 // interval binding on historical session bytes). Provider-stop retain authority is Sitian.
 import { COLLECTOR_BIND_TARGET_TOOL, COLLECTOR_OBSERVE_TOOL, COLLECTOR_READ_TOOL, COLLECTOR_REQUEST_TOOL, COLLECTOR_WAIT_TOOL, } from "../collector-ledger.js";
 import { ENGINE_DETOUR_TOOL_NAME } from "../engine-detour.js";
+import { projectEngineDetourToolUsageForPublicTerminal, readEngineDetourToolUsage, readInvocationEngineMounted, runDirectoryFromSessionDirectory, sessionFileFromSessionDirectory, withEngineDetourToolUsageFact, } from "../engine-detour-usage.js";
 import { JUDGE_OUTPUT_TOOL_NAME, } from "../package-contracts/judge-output.js";
 import { COLLECTOR_OUTPUT_TOOL, } from "../package-contracts/collector-output.js";
 import { CODER_OUTPUT_TOOL_NAME, FIXER_OUTPUT_TOOL_NAME, } from "../package-contracts/worker-output.js";
@@ -127,7 +128,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.
  */
-export async function settleHostEndedNoReceipt(admitted, authority) {
+export async function settleHostEndedNoReceipt(admitted, authority, scope) {
     const facts = noReceiptLifecycleFacts({
         terminalToolCalled: false,
         rejectedReceipts: [],
@@ -147,7 +148,7 @@ export async function settleHostEndedNoReceipt(admitted, authority) {
         navigator: await extractNavigatorFactFromAdmittedSession(coordinates.sessionFile),
         artifacts: [],
         runId: admitted.runId,
-    }, coordinates.sessionDirectory);
+    }, coordinates.sessionDirectory, detourGateContext(admitted, scope));
 }
 async function closedLedgerOutcome(admitted, role, scope) {
     return sealedLedgerOutcome(admitted, role, scope);
@@ -1589,6 +1590,57 @@ export async function extractGateFactFromSessionDirectory(sessionDirectory, opti
  * or swallowed); callers that already hold a controlled failure still surface the
  * JSONL/session cause rather than pretend the gate was absent.
  */
+/**
+ * #537: project this-invocation ak_engine_detour usage onto decisiveFacts.
+ * Absent when engine is not mounted; callCount 0 when mounted with zero calls.
+ * Never mutates role payloads (ADR 0003 / 0042 / 0052).
+ * Scope is the public-invocation id bound once per ak-role call — never
+ * courtAttemptId and never Pi session.jsonl toolResult join. Session damage
+ * therefore cannot replace an already-formed roleOutcome (no_receipt / failure).
+ */
+async function attachEngineDetourToolUsage(base, sessionDirectory, gateContext = {}) {
+    const runDirectory = typeof gateContext.runDirectory === "string" && gateContext.runDirectory.length > 0
+        ? gateContext.runDirectory
+        : runDirectoryFromSessionDirectory(sessionDirectory);
+    const engineMounted = await readInvocationEngineMounted(runDirectory);
+    if (!engineMounted)
+        return base;
+    // Public-invocation scope from the shared Host envelope (settlement scope), never
+    // courtAttemptId and never a detour sidecar file.
+    const invocationScopeId = typeof gateContext.invocationScopeId === "string" &&
+        gateContext.invocationScopeId.length > 0
+        ? gateContext.invocationScopeId
+        : undefined;
+    const sessionFile = sessionFileFromSessionDirectory(sessionDirectory);
+    const usage = await readEngineDetourToolUsage({
+        sessionParent: sessionFile,
+        engineMounted: true,
+        ...(invocationScopeId === undefined ? {} : { invocationScopeId }),
+        cwd: runDirectory,
+    });
+    const projected = usage === undefined
+        ? undefined
+        : projectEngineDetourToolUsageForPublicTerminal(usage, {
+            // Resumable Terminal: run ID only in resume.command — relative openable path.
+            discloseRecordFile: base.resume === undefined,
+        });
+    return {
+        ...base,
+        roleOutcome: withEngineDetourToolUsageFact(base.roleOutcome, projected),
+    };
+}
+/** Gate + detour projection context from admitted run + settlement scope. */
+function detourGateContext(admitted, scope) {
+    return {
+        runDirectory: admitted.runDirectory,
+        ...(scope?.courtAttemptId === undefined || scope.courtAttemptId.length === 0
+            ? {}
+            : { courtAttemptId: scope.courtAttemptId }),
+        ...(scope?.invocationScopeId === undefined || scope.invocationScopeId.length === 0
+            ? {}
+            : { invocationScopeId: scope.invocationScopeId }),
+    };
+}
 async function withOptionalGateProjection(base, sessionDirectory, gateContext = {}) {
     // A gate transport failure is already represented by typed evidence and has no
     // accepted gate cycle to project. Re-reading that rejected receipt as an
@@ -1596,15 +1648,19 @@ async function withOptionalGateProjection(base, sessionDirectory, gateContext =
     const secondaryEvidence = base.roleOutcome.kind === "failure"
         ? base.roleOutcome.decisiveFacts.secondaryEvidence
         : undefined;
-    if (isRecord(secondaryEvidence)
+    const skipGate = isRecord(secondaryEvidence)
         && secondaryEvidence.kind === "role_infrastructure_failure"
         && (secondaryEvidence.stage === "gatekeeper"
             || secondaryEvidence.stage === "inspector"
-            || secondaryEvidence.stage === "notary"))
-        return base;
-    // Defaults live solely in extractGateFactFromSessionDirectory — do not re-derive.
-    const gate = await extractGateFactFromSessionDirectory(sessionDirectory, gateContext);
-    return gate === undefined ? base : { ...base, gate };
+            || secondaryEvidence.stage === "notary");
+    let next = base;
+    if (!skipGate) {
+        // Defaults live solely in extractGateFactFromSessionDirectory — do not re-derive.
+        const gate = await extractGateFactFromSessionDirectory(sessionDirectory, gateContext);
+        if (gate !== undefined)
+            next = { ...base, gate };
+    }
+    return attachEngineDetourToolUsage(next, sessionDirectory, gateContext);
 }
 export function extractNavigatorFact(entries) {
     // Affirmative attendance only. Missing / uncorrelated / unparseable is never no-advice.
@@ -1814,7 +1870,7 @@ async function settleLawfulJudgeTerminalResult(admitted, authority, scope) {
         navigator,
         artifacts,
         runId: admitted.runId,
-    }, coordinates.sessionDirectory);
+    }, coordinates.sessionDirectory, detourGateContext(admitted, scope));
 }
 /**
  * Settle a lawful typed terminal result from the admitted session.
@@ -1854,7 +1910,7 @@ async function settleLawfulCoderTerminalResult(admitted, authority, options = {}
         navigator,
         artifacts,
         runId: admitted.runId,
-    }, coordinates.sessionDirectory);
+    }, coordinates.sessionDirectory, detourGateContext(admitted, scope));
 }
 /** Settle a lawful Coder Terminal from the admitted session (shared #106 success interface). */
 export async function settleCoderTerminalResult(admitted, authority, options = {}, scope) {
@@ -1974,7 +2030,7 @@ async function settleLawfulFixerTerminalResult(admitted, authority, options, sco
         navigator,
         artifacts,
         runId: admitted.runId,
-    }, sessionDirectory);
+    }, 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) {
@@ -2037,7 +2093,7 @@ async function settleLawfulCollectorTerminalResult(admitted, authority, scope) {
                 cause: "output",
                 diagnostic: residual.diagnostic,
                 details,
-            }, authority);
+            }, authority, scope ?? {});
             return attachRecordedSubmissions(admitted, failed, scope);
         }
         return undefined;
@@ -2050,7 +2106,7 @@ async function settleLawfulCollectorTerminalResult(admitted, authority, scope) {
         navigator,
         artifacts,
         runId: admitted.runId,
-    }, sessionDirectory), scope);
+    }, sessionDirectory, detourGateContext(admitted, scope)), scope);
 }
 /** Settle a lawful Collector Terminal from the admitted session. */
 export async function settleCollectorTerminalResult(admitted, authority, scope) {
@@ -2144,7 +2200,7 @@ async function settleLawfulDoctorTerminalResult(admitted, authority, scope) {
             navigator: extractNavigatorFact(entries),
             artifacts,
             runId: admitted.runId,
-        }, sessionDirectory);
+        }, sessionDirectory, detourGateContext(admitted, scope));
     }
     const roleOutcome = sealed;
     const navigator = extractNavigatorFact(entries);
@@ -2159,7 +2215,7 @@ async function settleLawfulDoctorTerminalResult(admitted, authority, scope) {
         navigator,
         artifacts,
         runId: admitted.runId,
-    }, sessionDirectory);
+    }, sessionDirectory, detourGateContext(admitted, scope));
 }
 /** Settle a lawful Doctor Terminal from the admitted session. */
 export async function settleDoctorTerminalResult(admitted, authority, scope) {
@@ -2203,7 +2259,7 @@ async function settleLawfulSeatAcceptedTerminalResult(admitted, authority, spec,
                 cause: "output",
                 diagnostic: residual.diagnostic,
                 details,
-            }, authority);
+            }, authority, scope ?? {});
             return withSubmissions(failed, submissions);
         }
     }
@@ -2215,7 +2271,7 @@ async function settleLawfulSeatAcceptedTerminalResult(admitted, authority, spec,
             navigator,
             artifacts: [],
             runId: admitted.runId,
-        }, sessionDirectory), submissions);
+        }, sessionDirectory, detourGateContext(admitted, scope)), submissions);
     }
     if (roleOutcome?.role === spec.role) {
         const navigator = extractNavigatorFact(entries);
@@ -2224,7 +2280,7 @@ async function settleLawfulSeatAcceptedTerminalResult(admitted, authority, spec,
             navigator,
             artifacts: [],
             runId: admitted.runId,
-        }, sessionDirectory), submissions);
+        }, sessionDirectory, detourGateContext(admitted, scope)), submissions);
     }
     return undefined;
 }
@@ -2429,7 +2485,7 @@ async function settleLawfulReviewerTerminalResult(admitted, authority, options,
         navigator,
         artifacts,
         runId: admitted.runId,
-    }, sessionDirectory);
+    }, 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) {
@@ -2525,7 +2581,7 @@ async function settleLawfulMergerTerminalResult(admitted, authority, options, sc
                 cause: "output",
                 diagnostic: residual.diagnostic,
                 details,
-            }, authority);
+            }, authority, scope ?? {});
             return attachRecordedSubmissions(admitted, failed, scope);
         }
         return undefined;
@@ -2544,7 +2600,7 @@ async function settleLawfulMergerTerminalResult(admitted, authority, options, sc
         navigator,
         artifacts,
         runId: admitted.runId,
-    }, sessionDirectory), scope);
+    }, 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) {
@@ -2760,7 +2816,7 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
                             navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
                             artifacts: [],
                             runId: admitted.runId,
-                        }, sessionDirectory);
+                        }, sessionDirectory, detourGateContext(admitted, options));
                     }
                 }
                 catch { /* malformed lifecycle bytes remain the existing nonzero output failure */ }
@@ -2801,7 +2857,7 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
             navigator,
             artifacts: [],
             resume: options.resume,
-        }, sessionDirectory);
+        }, sessionDirectory, detourGateContext(admitted, options));
     }
     const roleOutcome = {
         kind: "failure",
@@ -2816,7 +2872,7 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
         navigator,
         artifacts,
         runId: admitted.runId,
-    }, sessionDirectory);
+    }, sessionDirectory, detourGateContext(admitted, options));
 }
 /** Judge-named alias retained for #107 call sites. */
 export async function settleJudgeFailureTerminalResult(admitted, failure, authority, options = {}) {

package/dist/public-cli/turn-request.js

@@ -25,6 +25,9 @@ export function projectRoleTurnRequest(admitted, roleDetails, options) {
         ...(options.courtAttemptId === undefined || options.courtAttemptId.length === 0
             ? {}
             : { courtAttemptId: options.courtAttemptId }),
+        ...(options.invocationScopeId === undefined || options.invocationScopeId.length === 0
+            ? {}
+            : { invocationScopeId: options.invocationScopeId }),
         ...(options.stationChild === undefined ? {} : { stationChild: options.stationChild }),
     };
 }

package/package.json

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