@akagilnc/pi-workflow-roles 0.1.2089 → 0.1.2096

package/resources/engines/opus.md

@@ -14,18 +14,25 @@ The machine entrypoint is `claude`. Run from the role project root. Non-interact
 print mode (`-p` / `--print`) is verified available on this host:
 
 ```bash
-claude -p "YOUR_LABOR_PROMPT"
+claude -p --output-format=stream-json "YOUR_LABOR_PROMPT"
 ```
 
 Pin the Opus model explicitly (`--model opus` verified accepted on this host):
 
 ```bash
-claude -p --model opus "YOUR_LABOR_PROMPT"
+claude -p --model opus --output-format=stream-json "YOUR_LABOR_PROMPT"
 ```
 
+Use `--output-format=stream-json` (verified present on this host) so the package
+idle clock can see subprocess activity while the engine works; take the labor body
+from the final `result` event, not from intermediate stream rows.
+
 Prefer `claude --help` on the host over any remembered flag set. Do not wrap this
 engine behind `ak-role` flags.
 
-When the package detour tool is available, start exactly one subprocess through
-it with argv assembled from this material and the local CLI; return the stdout
-labor content to the same session for the existing typed submission path.
+When the package detour tool is available, start exactly one subprocess per
+labor invocation through it with argv assembled from this material and the
+local CLI; return the stdout labor content to the same session for the existing
+typed submission path. One labor turn = one process (not one process for the
+whole role run). If the detour fails, continue labor in-session on the seat main
+road and still submit via the existing typed path.

package/souls/judge.md

@@ -9,66 +9,58 @@
 - 主张不是证据。核对引文、代码、测试与历史；只把指向当前 head 的材料当作
   当前事实。修复者的自述不能替代新 head 上的机械验证和独立复查。
 - 每条问题都必须有显式记录和处置。严重度不是入场券；不得沉默遗漏，
-  也不得安静降级。驳回问题时必须给出可核验的理由和证据。
+  也不得安静降级。驳回须给出可核验的理由和证据。
 
 ## 案面
 
-**开工先立案。** 开庭先枚举本单**适用法源**——**宿主全局宪法与仓级治理文件必列**，
-以及 ADR、票面既裁、陛下裁定与其它既裁法源；逐项对表——引用不等于适用；再以法源与当前一手证据独立完成双向
-抽样重推（误删与该删未删同查），然后落判词。判词与驳回须能锚到具体法源；
-**无可依法源时不得以「无法可依」收敛，应上抛请立法**。**立案先于按派单收缩的
-审理范围。**
+**开工先立案。** 开庭先枚举本单适用法源——宿主全局宪法与仓级治理文件必列，
+以及 ADR、票面既裁、陛下裁定与其它既裁法源；逐项对表，引用不等于适用。
+**finding 的事实与处方分开对宪：事实成立而处方违宪时，保留事实，驳回处方或
+改开合宪处方。** 再以法源与当前一手证据独立完成双向抽样重推（误删与该删未删
+同查），然后落判词。判词与驳回须锚到具体法源；无可依法源时不得以「无法可依」
+收敛，应上抛请立法。立案先于按派单收缩的审理范围。
 
 **宪法优先，已批断言不容翻。** 动过既有断言的改动须溯源到票面授权、ADR 或
-先前裁定；权威仍在而相抵触即为 blocking。改动触及 `docs/adr/`、`CONTEXT.md`
-或其它治理法文件而票面未授权时，实质审理并在判词中点名；确属宪法问题则上抛。
+先前裁定；权威仍在而相抵触即为 blocking。改动触及治理法文件（含 `docs/adr/`、
+`CONTEXT.md`）而票面未授权时，实质审理并在判词中点名；确属宪法问题则上抛。
 
-**全部提交物都是案面**：票面、计划、处置清单、packet、**派单措辞与输入 prompt**、
-代码、测试。
+**全部提交物都是案面**：票面、计划、处置清单、packet、派单措辞与输入 prompt、
+代码、测试。举证责任由所审材料决定，不由派单指定；计划只审是否足以开工，
+实现细节归 Apply。
 
-**审查范围绑定本次授权的 target/range，并覆盖该范围内的完整变更与未声明的
-生产默认行为**；不得因派单或票面清单缩减适用的举证责任。派单非法缩 scope 时：
-可施工纠正的判 `continue`；属陛下取舍、法源冲突或无法安全裁定的判 `escalate`。
+**审查范围绑定本次授权的 target/range**，覆盖范围内完整变更与未声明的生产
+默认行为；不得因派单或票面清单缩减举证责任。派单非法缩 scope：可施工纠正判
+`continue`；属陛下取舍、法源冲突或无法安全裁定判 `escalate`。
 
-**落判前逐项过改动清单。** 授权 range 内每项改动都要标明由票面哪条驱动：**标不出
-来的即为夹带**（默认值、护栏、平行机制、仅测试用的生产钩子同论）；**票面有要求而
-清单中没有的即为缺口**。二者同为缺陷，须逐条处置；清单未列全不得收敛。
-
-## 举证责任
-
-举证责任由**所审材料**决定，不由派单指定。
-计划只审是否足以开工，实现细节归 Apply。
-
-**实现须与需求相符——多与少都是缺陷。** 票面要的没做到是缺陷；票面没要的
-自作主张同样是缺陷（夹带的默认值、护栏、平行机制、仅测试用的生产钩子同论）。
+**落判前逐项过改动清单，与票面双向对表。** 每项改动标明由票面哪条驱动，
+标不出来的即为夹带；票面有要求而清单没有的即为缺口（夹带的默认值、护栏、
+平行机制、仅测试用的生产钩子同论）。多与少同为缺陷，逐条处置；清单未列全
+不得收敛。
 
 ## 修理原则
 
-删除或简化根因优先于增加平行机制。提出或批准护栏前必须回答三问：
-
-1. 哪个真实、可复现的失败证明需要这道护栏？
-2. 哪个接缝拥有它要维护的不变式？
-3. 为什么删除或简化根因不足以解决这一类失败？
-
-同一接缝反复失败、根因不明、范围持续发散或出现 flake 时，应要求先做最小化、
-证据驱动的诊断。**一轮轮只加不减的修复流，本身就是该上报的病。**
+删除或简化根因优先于增加平行机制。提出或批准护栏前必答三问：①哪个真实、
+可复现的失败证明需要它？②哪个接缝拥有它要维护的不变式？③为什么删除或简化
+根因不足以解决这类失败？
 
 审查修复波及面，区分原始缺陷所需改动、修复引入后再修的改动和无依据的新机制；
-后两类主导时，优先删除/简化。超出**本次授权**的取舍必须上抛。
+后两类主导时优先删除/简化。超出本次授权的取舍必须上抛。**一轮轮只加不减的
+修复流，本身就是该上报的病。**
 
 ## 判词
 
 合法判词只有三种，含义相对所审材料的举证责任：
 
 - `converged` — 适用举证责任下的事项均已明确处置。修内司/将作监的提交另需：
-  本轮御史台无 p2 及以上 finding（p 级由你自行判定；被你驳回的 finding 不计数）。
+  本轮御史台无 p2 及以上 finding（p 级由你自行判定；被你驳回的不计数）。
 - `continue` — 仍有可施工的问题；给出清晰、可验证的修理正文。
 - `escalate` — 存在必须由陛下决定的门槛、相互冲突的法源，或依据失败走势
-  与专业证据已无法形成安全裁定；写明问题**和可选项**。
+  与专业证据已无法形成安全裁定；写明问题和可选项。
 
 **送修正文由你执笔——判词即包。** 首轮可薄（finding + 法源锚点 + 边界）；有
-病史则综合（病史全列、方向可钉、拆除清单明文）。判其发散（同缝反复、根因
-不明、疑跨接缝、flake）时，在送修单中提示先做诊断定根因。
+病史则综合（病史全列、方向可钉、拆除清单明文）。同缝反复、根因不明、范围
+持续发散、疑跨接缝或 flake 即为发散，送修单中要求先做最小化、证据驱动的
+诊断定根因。
 
 `continue` 的 `classes` 只含尚未结清、须派施工的根因类；已结清项、过程账、
 双向抽样不得进 classes。

package/src/engine-detour-tool.ts

@@ -1,7 +1,10 @@
 /**
- * Package-owned engine detour tool (#357 T2 / #378).
+ * Package-owned engine detour tool (#357 T2 / #378 / #380).
  * Registered by shared role-runtime when Judge|Reviewer + engine activation signal is present.
  * Evidence-child legs install the same definition via customTools (no spawn in role modules).
+ * #380: engine process failure soft-returns so the seat rejoins the main road; declaration
+ * is recorded once via engine-labor-fallback (no fail-closed reject-leg).
+ * Caller AbortSignal cancel propagates without fallback; package-owned idle abort soft-fails.
  */
 import type {
   AgentToolResult,
@@ -19,7 +22,16 @@ import {
   isEngineDetourFailure,
   runEngineDetourOnce,
 } from "./engine-detour.ts";
-import { wrapPackageOwnedToolDefinition } from "./package-owned-tool-idle.ts";
+import {
+  activationEngineLaborFallbackLatch,
+  recordEngineLaborFallback,
+  type EngineLaborFallbackField,
+} from "./engine-labor-fallback.ts";
+import {
+  isPackageOwnedToolIdleTimeoutError,
+  pokePackageOwnedToolIdle,
+  wrapPackageOwnedToolDefinition,
+} from "./package-owned-tool-idle.ts";
 
 const engineDetourArgsSchema = Type.Object(
   {
@@ -49,10 +61,55 @@ export type EngineDetourToolRegistration = {
 
 type EngineDetourLatch = { used: boolean };
 
+function seatFallbackToolResult(
+  field: EngineLaborFallbackField,
+  failure: string,
+): AgentToolResult<unknown> {
+  return {
+    content: [
+      {
+        type: "text" as const,
+        text:
+          `Engine detour failed: ${failure}. Perform the labor in this session (seat main road) and submit via the existing typed path. A mechanical fallback declaration will attach to the typed receipt.`,
+      },
+    ],
+    details: {
+      tool: ENGINE_DETOUR_TOOL_NAME,
+      detourFailed: true,
+      ...field,
+    },
+  };
+}
+
+/** Caller/upper-layer cancel must propagate; idle backstop is seat-fallback, not cancel. */
+function isCallerCancellation(
+  error: unknown,
+  signal: AbortSignal | undefined,
+): boolean {
+  if (isPackageOwnedToolIdleTimeoutError(error)) return false;
+  if (
+    signal !== undefined &&
+    isPackageOwnedToolIdleTimeoutError(signal.reason)
+  ) {
+    return false;
+  }
+  if (signal?.aborted === true) return true;
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    (error as { name?: unknown }).name === "AbortError"
+  ) {
+    return true;
+  }
+  return false;
+}
+
 /**
  * Build one once-latch detour tool definition for a configured engine name.
  * `latch` is shared so parent registration can reset between activations.
- * `fail` owns host abort (parent) vs throw (evidence child).
+ * `fail` owns host abort (parent) vs throw (evidence child) for tool misuse only.
+ * Engine process failure (nonzero/empty/spawn/idle-timeout) soft-returns seat fallback (#380).
+ * Caller AbortSignal cancel propagates without writing fallback.
  */
 export function createEngineDetourToolDefinition(input: {
   engineName: string;
@@ -71,6 +128,7 @@ export function createEngineDetourToolDefinition(input: {
       `Use ${ENGINE_DETOUR_TOOL_NAME} exactly once for the configured engine (${engineName}). Optional packaged notes are guidance when present; a bare engine name alone is also a valid call path.`,
       "Pass argv for the host CLI of this engine name — first element is the executable name on PATH. Follow optional packaged notes when delivered; otherwise act from the engine name and the host CLI actual interface. Do not invent package flags.",
       "On success, use the returned stdout as labor content for the existing typed submission / report path.",
+      "On engine failure the tool returns a soft failure: continue labor in this session and submit via the existing typed path. Do not treat engine failure as a reason to withhold the typed receipt.",
     ],
     parameters: engineDetourArgsSchema,
     async execute(
@@ -99,27 +157,39 @@ export function createEngineDetourToolDefinition(input: {
         );
       }
 
+      const softFail = (failure: string): AgentToolResult<unknown> => {
+        // Activation-scoped latch is the sole shared recorder (parent seat + legs).
+        const fallbackLatch =
+          activationEngineLaborFallbackLatch() ?? { field: undefined };
+        const field = recordEngineLaborFallback(fallbackLatch, {
+          engine: engineName,
+          failure,
+        });
+        return seatFallbackToolResult(field, failure);
+      };
+
       let result: Awaited<ReturnType<typeof runEngineDetourOnce>>;
       try {
+        // Byte activity on stdout/stderr touches the outer package-owned idle clock
+        // (183s silence law unchanged). True hangs still die; slow streaming engines live.
         result = await runEngineDetourOnce({
           argv,
           cwd: ctx.cwd,
           ...(signal === undefined ? {} : { signal }),
+          onOutputActivity: pokePackageOwnedToolIdle,
         });
       } catch (error) {
-        input.fail(
-          error instanceof Error ? error : new Error(String(error)),
-          toolCallId,
-          ctx,
-        );
+        // Caller cancel: propagate. Idle backstop + spawn/engine failure: seat fallback.
+        if (isCallerCancellation(error, signal)) {
+          throw error;
+        }
+        const failure =
+          error instanceof Error ? error.message : String(error);
+        return softFail(failure.trim() === "" ? "engine detour spawn failed" : failure);
       }
 
       if (isEngineDetourFailure(result)) {
-        input.fail(
-          new Error(engineDetourFailureDiagnostic(result)),
-          toolCallId,
-          ctx,
-        );
+        return softFail(engineDetourFailureDiagnostic(result));
       }
 
       return {

package/src/engine-detour.ts

@@ -28,11 +28,28 @@ export type EngineDetourRunInput = Readonly<{
   cwd: string;
   env?: NodeJS.ProcessEnv;
   signal?: AbortSignal;
+  /**
+   * Called when the child emits at least one byte on stdout or stderr.
+   * Host wires this to the package-owned idle clock (activity = touch); no timer here.
+   */
+  onOutputActivity?: () => void;
 }>;
 
+function abortReasonError(signal: AbortSignal): Error {
+  const reason = signal.reason;
+  if (reason instanceof Error) return reason;
+  if (typeof reason === "string" && reason.trim() !== "") {
+    return new Error(reason);
+  }
+  const error = new Error("aborted");
+  error.name = "AbortError";
+  return error;
+}
+
 /**
  * Run one engine subprocess. First argv element is the executable (PATH lookup).
  * stdio: ignore stdin, pipe stdout+stderr. No shell, no retry, no hang timer.
+ * AbortSignal cancels the child immediately via an explicit listener (reason preserved).
  */
 export async function runEngineDetourOnce(
   input: EngineDetourRunInput,
@@ -44,30 +61,64 @@ export async function runEngineDetourOnce(
   const args = input.argv.slice(1);
   return await new Promise<EngineDetourResult>((resolve, reject) => {
     let settled = false;
+    const signal = input.signal;
+    // Own abort→kill explicitly so rejection preserves signal.reason (caller cancel
+    // vs package-owned idle). Do not pass `signal` to spawn (Node replaces reason).
     const child = spawn(command, args, {
       cwd: input.cwd,
       env: input.env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"],
-      ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
     let stdout = "";
     let stderr = "";
+    const noteActivity = (chunk: string): void => {
+      if (chunk.length === 0) return;
+      input.onOutputActivity?.();
+    };
     child.stdout.setEncoding("utf8").on("data", (chunk: string) => {
       stdout += chunk;
+      noteActivity(chunk);
     });
     child.stderr.setEncoding("utf8").on("data", (chunk: string) => {
       stderr += chunk;
+      noteActivity(chunk);
     });
     const fail = (error: unknown): void => {
       if (settled) return;
       settled = true;
+      if (signal !== undefined) {
+        signal.removeEventListener("abort", onAbort);
+      }
       reject(error instanceof Error ? error : new Error(String(error)));
     };
-    child.on("error", (error) => fail(error));
-    child.on("close", (code) => {
+    const succeed = (result: EngineDetourResult): void => {
       if (settled) return;
       settled = true;
-      resolve({ code: code ?? 1, stdout, stderr });
+      if (signal !== undefined) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve(result);
+    };
+    const onAbort = (): void => {
+      // Fail synchronously so cooperative idle/cancel paths can soft-settle
+      // before the outer package-owned idle hard-reject drain.
+      fail(signal !== undefined ? abortReasonError(signal) : new Error("aborted"));
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        // already exited
+      }
+    };
+    if (signal !== undefined) {
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+    child.on("error", (error) => fail(error));
+    child.on("close", (code) => {
+      succeed({ code: code ?? 1, stdout, stderr });
     });
   });
 }

package/src/engine-labor-fallback.ts

@@ -0,0 +1,172 @@
+/**
+ * #380 — sole shared seat-fallback declaration after engine detour failure.
+ * Detour rejoins the main road (ADR 0069); silence is the only crime.
+ * Construction of the typed receipt field lives in exactly one site (S1).
+ */
+
+export type EngineLaborFallback = Readonly<{
+  engine: string;
+  failure: string;
+  laborBy: "seat";
+}>;
+
+/** Activation-scoped latch holder (one parent seat activation at a time). */
+let activationLatch: EngineLaborFallbackLatch | undefined;
+
+/** Sole construction site for typed receipt field `engineLaborFallback` (#380 S1). */
+export function buildEngineLaborFallbackField(input: {
+  readonly engine: string;
+  readonly failure: string;
+}) {
+  return Object.freeze({
+    engineLaborFallback: Object.freeze({
+      engine: input.engine,
+      failure: input.failure,
+      laborBy: "seat" as const,
+    }),
+  });
+}
+
+/** Frozen field bag produced by the sole construction site. */
+export type EngineLaborFallbackField = ReturnType<
+  typeof buildEngineLaborFallbackField
+>;
+
+export type EngineLaborFallbackLatch = {
+  field: EngineLaborFallbackField | undefined;
+};
+
+export function createEngineLaborFallbackLatch(): EngineLaborFallbackLatch {
+  return { field: undefined };
+}
+
+/**
+ * Record first detour failure for this latch (first wins; parallel legs share one field).
+ * Always returns the latched first-wins value so tool details and receipt projection match.
+ */
+export function recordEngineLaborFallback(
+  latch: EngineLaborFallbackLatch,
+  input: { readonly engine: string; readonly failure: string },
+): EngineLaborFallbackField {
+  const field = buildEngineLaborFallbackField(input);
+  if (latch.field === undefined) latch.field = field;
+  return latch.field;
+}
+
+export function readEngineLaborFallbackField(
+  latch: EngineLaborFallbackLatch | undefined,
+): EngineLaborFallbackField | undefined {
+  return latch?.field;
+}
+
+/**
+ * Merge sole-built field into typed receipt details.
+ * Spread only — must not construct the field key again (S1).
+ * Without a mechanical latch, strip any model-injected reserved key (no forged declaration).
+ */
+export function withEngineLaborFallbackField<T extends object>(
+  receipt: T,
+  field: EngineLaborFallbackField | undefined,
+): T {
+  if (field !== undefined) {
+    return { ...receipt, ...field };
+  }
+  if (
+    !Object.prototype.hasOwnProperty.call(receipt, "engineLaborFallback")
+  ) {
+    return receipt;
+  }
+  const { engineLaborFallback: _forged, ...rest } = receipt as T & {
+    engineLaborFallback?: unknown;
+  };
+  return rest as T;
+}
+
+/** Install the activation-scoped latch (Judge/Reviewer session_start). */
+export function installActivationEngineLaborFallbackLatch(
+  latch: EngineLaborFallbackLatch,
+): void {
+  activationLatch = latch;
+}
+
+/** Clear activation latch (session end / next activation). */
+export function clearActivationEngineLaborFallbackLatch(): void {
+  activationLatch = undefined;
+}
+
+/** Active activation latch, if any (legs inherit parent seat activation). */
+export function activationEngineLaborFallbackLatch():
+  | EngineLaborFallbackLatch
+  | undefined {
+  return activationLatch;
+}
+
+/** Read fallback field from the active activation latch. */
+export function readActivationEngineLaborFallbackField():
+  | EngineLaborFallbackField
+  | undefined {
+  return readEngineLaborFallbackField(activationLatch);
+}
+
+/**
+ * Read a previously attached declaration from a typed receipt / details object.
+ * Rebuilds via the sole construction site — callers must spread, never re-key.
+ */
+export function readEngineLaborFallbackFieldFrom(
+  source: unknown,
+): EngineLaborFallbackField | undefined {
+  if (typeof source !== "object" || source === null || Array.isArray(source)) {
+    return undefined;
+  }
+  let raw: unknown;
+  try {
+    raw = (source as Record<string, unknown>).engineLaborFallback;
+  } catch {
+    return undefined;
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return undefined;
+  const rec = raw as Record<string, unknown>;
+  if (
+    typeof rec.engine !== "string" ||
+    typeof rec.failure !== "string" ||
+    rec.laborBy !== "seat"
+  ) {
+    return undefined;
+  }
+  return buildEngineLaborFallbackField({
+    engine: rec.engine,
+    failure: rec.failure,
+  });
+}
+
+/**
+ * Restore activation latch from durable session tool results (#380 resume).
+ * Scans existing same-session detour tool results only — no sidecar / new entry type.
+ * Replays through recordEngineLaborFallback so first-wins + sole producer stay intact.
+ */
+export function restoreEngineLaborFallbackFromSessionEntries(
+  latch: EngineLaborFallbackLatch,
+  entries: readonly unknown[],
+  toolName: string,
+): void {
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const row = entry as { type?: unknown; message?: unknown };
+    if (row.type !== "message") continue;
+    const message = row.message;
+    if (typeof message !== "object" || message === null) continue;
+    const msg = message as {
+      role?: unknown;
+      toolName?: unknown;
+      details?: unknown;
+    };
+    if (msg.role !== "toolResult") continue;
+    if (msg.toolName !== toolName) continue;
+    const field = readEngineLaborFallbackFieldFrom(msg.details);
+    if (field === undefined) continue;
+    recordEngineLaborFallback(latch, {
+      engine: field.engineLaborFallback.engine,
+      failure: field.engineLaborFallback.failure,
+    });
+  }
+}

package/src/evidence-child-executor.ts

@@ -596,17 +596,15 @@ export async function executeEvidenceChild(
                 engine: engineName,
                 packageRoot: options.packageRoot,
               });
-      // #378: detour failure is durable for this leg — later assistant reports cannot wash it.
-      let engineDetourFailure: Error | undefined;
+      // #378/#380: same detour tool as parent seat. Engine process failure soft-returns
+      // seat main-road fallback (ADR 0069 detour-rejoins-main-road); tool misuse still throws.
       const engineDetourTool =
         engineName === undefined
           ? undefined
           : createEngineDetourToolDefinition({
               engineName,
               fail(error) {
-                const failure = error instanceof Error ? error : new Error(String(error));
-                engineDetourFailure = failure;
-                throw failure;
+                throw error instanceof Error ? error : new Error(String(error));
               },
             });
       // No tools allowlist — Pi defaults + unrestricted evidence surface (ADR 0064).
@@ -642,18 +640,8 @@ export async function executeEvidenceChild(
         try {
           await session.prompt(delivered);
         } catch (error) {
-          // Engine detour fail becomes isError toolResult and must outrank a later
-          // provider-shaped throw from the same prompt turn (#378).
-          if (engineDetourFailure !== undefined) {
-            throw classifiedError(engineDetourFailure, "child");
-          }
           throw classifiedError(error, "provider");
         }
-        // Launched-leg detour non-zero / empty stdout / spawn failure is infrastructure:
-        // reject the leg even when the model still emits a non-blank report afterward.
-        if (engineDetourFailure !== undefined) {
-          throw classifiedError(engineDetourFailure, "child");
-        }
         if (signal?.aborted) throw new Error("Evidence child was cancelled");
         const lastAssistant = [...session.messages]
           .reverse()

package/src/judge-role.ts

@@ -8,6 +8,10 @@ import { Type, type Static } from "typebox";
 
 import { disposeComplianceDecision } from "./audit-escalation.ts";
 import type { ComplianceDecision } from "./compliance-transport.ts";
+import {
+  readActivationEngineLaborFallbackField,
+  withEngineLaborFallbackField,
+} from "./engine-labor-fallback.ts";
 
 import {
   JUDGE_OUTPUT_TOOL_NAME,
@@ -126,18 +130,21 @@ export function createJudgeRoleRuntime(
             } catch (error) {
               hostActions.failInfrastructure(error, ctx, toolCallId);
             }
+            // #380: attach sole-built engineLaborFallback when detour fell back to seat labor.
+            const laborFallback = readActivationEngineLaborFallbackField();
+            const acceptedDetails = withEngineLaborFallbackField(verdict, laborFallback);
             return disposeComplianceDecision<AgentToolResult<unknown>>(
               audit,
               {
                 pass: (usage) => ({
                   content: [{ type: "text" as const, text: "Judge verdict accepted" }],
-                  details: verdict,
+                  details: acceptedDetails,
                   terminate: true as const,
                   ...(usage === undefined ? {} : { usage }),
                 }),
                 noReceipt: (auditNoReceipt, usageProjection) => ({
                   content: [{ type: "text" as const, text: "Judge verdict accepted; compliance audit produced no receipt" }],
-                  details: { ...verdict, auditNoReceipt },
+                  details: { ...acceptedDetails, auditNoReceipt },
                   terminate: true as const,
                   ...usageProjection,
                 }),
@@ -149,7 +156,8 @@ export function createJudgeRoleRuntime(
                 escalate: (result) => result,
                 auditIncomplete: (result) => result,
               },
-              verdict,
+              // #380: escalate deliveredOutput must carry the same mechanical projection.
+              acceptedDetails,
             );
           },
         });