@akagilnc/pi-workflow-roles 0.1.2383 → 0.1.2402

package/package.json

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

package/scripts/build-package.mjs

@@ -9,8 +9,7 @@ const entries = [
   "work-subject-identity",
   "navigator-invocation-identity",
   "navigator-attendance",
-  // Navigator package-graph dependency (seat-fallback base status / ADR 0071).
-  "engine-labor-fallback",
+  // Navigator package-graph dependencies used by attendance settlement.
   "activation-ledger-git",
   "activation-ledger-topology",
   "activation-reconciliation",

package/src/analyst-gate-cycles-read.ts

@@ -16,10 +16,9 @@
  * An accepted gate terminating receipt (isError:false pair on dispatch/officer
  * tool) whose required typed facts are unusable — status, dispatch officer, or
  * first/last span missing/unknown/unparseable/inverted — also fails loudly via
- * the same throw→ledger `auditor-roles` unreadable seam. Lawful Gatekeeper
- * typed `incomplete` is a recognizable terminal (omit from pairing, leg stays
- * readable) — only unknown/non-contract dispatch status stays loud. True
- * non-gate volumes (soul-audit noise, etc.) stay omitted from pairing.
+ * the same throw→ledger `auditor-roles` unreadable seam. Unknown/non-contract
+ * dispatch status stays loud (#475 abolished Gatekeeper incomplete special-case).
+ * True non-gate volumes (soul-audit noise, etc.) stay omitted from pairing.
  */
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
@@ -36,7 +35,7 @@ export type AnalystGateCycleRound = {
   readonly roundIndex: number;
   /** Current English officer face after historical alias fold. */
   readonly officer: "inspector" | "notary";
-  /** Typed officer terminal status (pass / bounce / incomplete / …). */
+  /** Typed officer terminal status (pass / bounce / …). */
   readonly status: string;
   /** Officer subsession first→last usable timestamp delta (ms). */
   readonly officerWallMs: number;
@@ -237,9 +236,7 @@ async function classifyAuditorVolume(
   const findingsCount = findings.length;
 
   if (DISPATCH_TOOLS.has(call.toolName)) {
-    // Gatekeeper contract terminals: dispatch | incomplete. Incomplete is a
-    // lawful zero-pair terminal (#434-436 / #458) — never wash the parent leg.
-    if (status === "incomplete") return undefined;
+    // Gatekeeper contract terminal is dispatch only (#475).
     if (status !== "dispatch") {
       throw new Error(
         `accepted dispatch receipt has non-dispatch status ${JSON.stringify(status)} in ${filePath}`,

package/src/analyst-metric-families/acceptance-success-rework.ts

@@ -9,7 +9,6 @@
  * - success rate den = success-eligible accepted legs (no-receipt out; planned out)
  * - planned = plan-duty acceptance; never success numerator or denominator
  */
-import { seatFallbackBaseStatus } from "../engine-labor-fallback.ts";
 import type { AnalystReadableRunFacts, AnalystRunTerminalFace } from "../analyst-ledger.ts";
 import { medianNumber } from "../analyst-median.ts";
 import type { AnalystMetricFamilyModule } from "../analyst-metric-family.ts";
@@ -186,10 +185,8 @@ function mapTerminal(
     };
   }
 
-  // Seat-fallback taint is visible on the label; acceptance/success use base semantics.
-  const statusBase = seatFallbackBaseStatus(status);
   const acceptedSet = ACCEPTED_STATUS[role];
-  if (acceptedSet === undefined || !acceptedSet.has(statusBase)) {
+  if (acceptedSet === undefined || !acceptedSet.has(status)) {
     return {
       terminalLabel: status,
       accepted: false,
@@ -199,9 +196,9 @@ function mapTerminal(
     };
   }
 
-  const plannedDuty = WORKER_ROLES.has(role) && statusBase === "planned";
+  const plannedDuty = WORKER_ROLES.has(role) && status === "planned";
   const successSet = SUCCESS_STATUS[role] ?? new Set<string>();
-  const success = !plannedDuty && successSet.has(statusBase);
+  const success = !plannedDuty && successSet.has(status);
   const successEligible = !plannedDuty;
 
   return {

package/src/audit-escalation.ts

@@ -1,7 +1,6 @@
 import type { Usage } from "@earendil-works/pi-ai";
 
 import type {
-  ComplianceAuditIncomplete,
   ComplianceDecision,
 } from "./compliance-transport.ts";
 
@@ -35,13 +34,6 @@ export type AuditEscalationToolResult = {
   usage?: Usage;
 };
 
-export type AuditIncompleteToolResult = {
-  content: [{ type: "text"; text: string }];
-  details: ComplianceAuditIncomplete;
-  terminate: true;
-  usage?: Usage;
-};
-
 /**
  * Build the escalation delivery face.
  * Role-delivered fields ride under the escalation discriminator (ADR 0055).
@@ -119,17 +111,6 @@ export function projectAuditEscalation(
   };
 }
 
-export function projectAuditIncomplete(
-  decision: ComplianceAuditIncomplete,
-): AuditIncompleteToolResult {
-  return {
-    content: [{ type: "text", text: "Compliance audit incomplete; no role receipt was formed." }],
-    details: decision,
-    terminate: true,
-    ...(decision.usage === undefined ? {} : { usage: decision.usage }),
-  };
-}
-
 /**
  * Discriminator-only recognition (ADR 0040). Shape of conflicts/options/gate
  * is not a reject gate — element types and cardinality are delivery content.
@@ -152,7 +133,6 @@ export type ComplianceDecisionHandlers<T> = {
   ) => T | PromiseLike<T>;
   revise: (violations: readonly unknown[]) => T | PromiseLike<T>;
   escalate: (result: AuditEscalationToolResult) => T | PromiseLike<T>;
-  auditIncomplete?: (result: AuditIncompleteToolResult) => T | PromiseLike<T>;
 };
 
 /**
@@ -183,10 +163,5 @@ export async function disposeComplianceDecision<T>(
       return await handlers.escalate(
         projectAuditEscalation(decision, deliveredOutput),
       );
-    case "audit-incomplete":
-      if (handlers.auditIncomplete === undefined) {
-        throw new Error("Compliance audit-incomplete handler is unavailable");
-      }
-      return await handlers.auditIncomplete(projectAuditIncomplete(decision));
   }
 }

package/src/collector-role.ts

@@ -4,10 +4,6 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import type { Static } from "typebox";
 
-import {
-  readActivationEngineLaborFallbackField,
-  withEngineLaborFallbackField,
-} from "./engine-labor-fallback.ts";
 import {
   COLLECTOR_FIXED_KICKOFF,
   emptyCollectorManifest,
@@ -422,10 +418,7 @@ export function createCollectorRoleRuntime(
           );
           activation.ledger.markOutputAccepted();
           activation.ledger.completeOperational(toolCallId);
-          const acceptedDetails = withEngineLaborFallbackField(
-            receipt,
-            readActivationEngineLaborFallbackField(),
-          );
+          const acceptedDetails = receipt;
           return {
             content: [{
               type: "text" as const,

package/src/compliance-transport.ts

@@ -15,9 +15,30 @@ export type ComplianceAuditObservation =
   | { kind: "non-object-arguments"; type: ComplianceArgumentRootType }
   | { kind: "object-status-unreadable"; status: "missing" | "unknown" }
   | DossierObservation;
-export type ComplianceAuditIncomplete = { status: "audit-incomplete"; observation: ComplianceAuditObservation; candidate: unknown; usage?: Usage };
 export type ComplianceNoReceipt = NoReceiptLifecycleFacts & { status: "no-receipt"; usage?: Usage };
-export type ComplianceDecision = { status: "pass"; usage?: Usage } | { status: "revise"; violations: readonly unknown[]; usage?: Usage } | { status: "escalate"; conflicts?: unknown; decisionGate?: unknown; usage?: Usage } | ComplianceNoReceipt | ComplianceAuditIncomplete;
+export type ComplianceDecision = { status: "pass"; usage?: Usage } | { status: "revise"; violations: readonly unknown[]; usage?: Usage } | { status: "escalate"; conflicts?: unknown; decisionGate?: unknown; usage?: Usage } | ComplianceNoReceipt;
+
+/** Unreadable compliance candidate — infrastructure failure, not a judgment status (#475). */
+export class ComplianceCandidateUnreadableError extends Error {
+  readonly observation: ComplianceAuditObservation;
+  readonly candidate: unknown;
+  readonly usage?: Usage;
+  constructor(observation: ComplianceAuditObservation, candidate: unknown, usage?: Usage) {
+    const detail =
+      observation.kind === "non-object-arguments"
+        ? `${observation.kind}:${observation.type}`
+        : observation.kind === "object-status-unreadable"
+          ? `${observation.kind}:${observation.status}`
+          : observation.kind === "missing-subject"
+            ? `${observation.kind}:${observation.subject}`
+            : observation.kind;
+    super(`Compliance candidate unreadable: ${detail}`);
+    this.name = "ComplianceCandidateUnreadableError";
+    this.observation = observation;
+    this.candidate = candidate;
+    if (usage !== undefined) this.usage = usage;
+  }
+}
 export type ComplianceDispatch = { model: Model<Api>; auth: { apiKey?: string; headers?: Record<string, string | null>; env?: Record<string, string> } };
 
 /** Zero-projection kickoff — soul already carries dossier-fetch duty; no hand-delivered materials. */
@@ -25,8 +46,9 @@ export const AUDITOR_DOSSIER_PROMPT = "Audit the current run dossier." as const;
 
 const nonblank = Type.String({ minLength: 1, pattern: "\\S" });
 const decisionGateSchema = Type.Object({ question: nonblank, options: Type.Array(nonblank, { minItems: 1 }) }, { additionalProperties: false });
-// Transport must retain malformed candidates so they can settle as typed
-// audit-incomplete outcomes; status values are guidance, not a schema gate.
+// Transport retains malformed candidates on ComplianceCandidateUnreadableError so
+// the existing failure channel can publish observation + candidate (#475).
+// Status values are guidance, not a schema gate.
 export const complianceDecisionSchema = Type.Object({ status: Type.Unknown({ description: "Auditor decision status." }), violations: Type.Array(nonblank, { description: "Observed compliance violations." }), conflicts: Type.Array(nonblank, { description: "Unresolved authority or execution conflicts." }), decisionGate: Type.Union([decisionGateSchema, Type.Null()], { description: "Escalation question and available options." }) }, { additionalProperties: true, required: [] });
 
 export function createComplianceDecisionTool(name: string, description: string) {
@@ -93,12 +115,22 @@ function retainComplianceResponse(context: ExtensionContext, response: Assistant
 }
 function readListField(value: unknown): readonly unknown[] { return Array.isArray(value) ? value : value === undefined ? [] : [value]; }
 export function readComplianceCandidate(arguments_: unknown, usage?: Usage): ComplianceDecision {
-  if (typeof arguments_ !== "object" || arguments_ === null || Array.isArray(arguments_)) return { status: "audit-incomplete", observation: { kind: "non-object-arguments", type: arguments_ === null ? "null" : Array.isArray(arguments_) ? "array" : typeof arguments_ as ComplianceArgumentRootType }, candidate: arguments_, ...(usage === undefined ? {} : { usage }) };
+  if (typeof arguments_ !== "object" || arguments_ === null || Array.isArray(arguments_)) {
+    throw new ComplianceCandidateUnreadableError(
+      { kind: "non-object-arguments", type: arguments_ === null ? "null" : Array.isArray(arguments_) ? "array" : typeof arguments_ as ComplianceArgumentRootType },
+      arguments_,
+      usage,
+    );
+  }
   const args = arguments_ as Record<string, unknown>; const status = args.status;
   if (status === "pass") return { status, ...(usage === undefined ? {} : { usage }) };
   if (status === "revise") return { status, violations: readListField(args.violations), ...(usage === undefined ? {} : { usage }) };
   if (status === "escalate") return { status, ...(Object.hasOwn(args, "conflicts") ? { conflicts: args.conflicts } : {}), ...(Object.hasOwn(args, "decisionGate") ? { decisionGate: args.decisionGate } : {}), ...(usage === undefined ? {} : { usage }) };
-  return { status: "audit-incomplete", observation: { kind: "object-status-unreadable", status: status === undefined ? "missing" : "unknown" }, candidate: arguments_, ...(usage === undefined ? {} : { usage }) };
+  throw new ComplianceCandidateUnreadableError(
+    { kind: "object-status-unreadable", status: status === undefined ? "missing" : "unknown" },
+    arguments_,
+    usage,
+  );
 }
 
 export type RunComplianceAuditOptions = {

package/src/doctor-auditor.ts

@@ -10,8 +10,8 @@ import {
 } from "./compliance-transport.ts";
 import {
   readDoctorAuditSubjects,
+  requireAuditMaterials,
   resolveAuditDossier,
-  toAuditIncomplete,
 } from "./dossier-resolution.ts";
 
 export const DOCTOR_AUDIT_TOOL_NAME = "ak_doctor_audit_decision";
@@ -35,9 +35,9 @@ export function createPiDoctorAuditor(
 ): (options: DoctorAuditOptions) => Promise<ComplianceDecision> {
   return async (options) => {
     const dossier = resolveAuditDossier();
-    if (dossier.status === "incomplete") return toAuditIncomplete(dossier.observation);
+    requireAuditMaterials(dossier);
     const subjects = readDoctorAuditSubjects(options.context);
-    if (subjects.status === "incomplete") return toAuditIncomplete(subjects.observation);
+    requireAuditMaterials(subjects);
 
     return runComplianceAudit({
       tool,

package/src/doctor-contracts.ts

@@ -1,10 +1,5 @@
 import { Type } from "typebox";
 import { canonicalJson } from "./canonical-json.ts";
-import {
-  seatFallbackBaseStatus,
-  seatFallbackStatusHasLawfulEvidence,
-  type WithEngineLaborFallback,
-} from "./engine-labor-fallback.ts";
 import { openToolObjectFromUnion } from "./open-tool-schema.ts";
 
 export const DOCTOR_EVIDENCE_TOOL_NAME = "ak_doctor_evidence";
@@ -42,13 +37,9 @@ export type DoctorFinding =
 export type DoctorSubmission =
   | { status: "completed"; case: DoctorCaseIdentity; findings: DoctorFinding[] }
   | { status: "refused"; reason: string; missingEvidence: Array<{ need: string; targetKeys: string[] }> };
-type DoctorOutputClean =
+export type DoctorOutput =
   | { status: "completed"; case: DoctorCaseIdentity; findings: DoctorFinding[]; cost: DoctorCaseCost }
   | Extract<DoctorSubmission, { status: "refused" }>;
-/** Clean recorded shape or seat-fallback tainted accepted receipt (ADR 0071). */
-export type DoctorOutput =
-  | DoctorOutputClean
-  | WithEngineLaborFallback<DoctorOutputClean>;
 export type DoctorEvidenceEntry = { id: string; kind: "session" | "stderr"; byteLength: number; contentLength: number; sha256: string; content: string };
 export type DoctorCase = { version: 1; identity: DoctorCaseIdentity; evidence: DoctorEvidenceEntry[]; cost: DoctorCaseCost };
 
@@ -105,19 +96,13 @@ function isRecord(value: unknown): value is Record<string, unknown> { return typ
 function read(value: unknown, key: string): unknown { if (!isRecord(value)) return undefined; try { return value[key]; } catch { return undefined; } }
 export function validateDoctorSubmissionShape(value: unknown): DoctorSubmission {
   const status = read(value, "status");
-  const base = typeof status === "string" ? seatFallbackBaseStatus(status) : status;
-  if (base !== "completed" && base !== "refused") throw new DoctorSubmissionContractError("Doctor submission has no recognized execution status");
-  // ADR 0071: tainted status requires latch-shaped engineLaborFallback evidence.
-  if (typeof status === "string" && !seatFallbackStatusHasLawfulEvidence(status, value)) {
-    throw new DoctorSubmissionContractError("Doctor submission has no recognized execution status");
-  }
+  if (status !== "completed" && status !== "refused") throw new DoctorSubmissionContractError("Doctor submission has no recognized execution status");
   return value as DoctorSubmission;
 }
 export function validateRecordedDoctorOutput(value: unknown): DoctorOutput {
   const output = validateDoctorSubmissionShape(value);
   const status = read(output, "status");
-  const base = typeof status === "string" ? seatFallbackBaseStatus(status) : status;
-  if (base === "completed" && read(output, "cost") === undefined) throw new Error("Completed Doctor receipt has no runtime-owned cost testimony");
+  if (status === "completed" && read(output, "cost") === undefined) throw new Error("Completed Doctor receipt has no runtime-owned cost testimony");
   return output as DoctorOutput;
 }
 

package/src/doctor-role.ts

@@ -2,10 +2,6 @@ import type { AgentToolResult, ExtensionAPI, ExtensionContext } from "@earendil-
 import { disposeComplianceDecision } from "./audit-escalation.ts";
 import { appendActiveSessionCustomEntry, type ComplianceDecision } from "./compliance-transport.ts";
 import { DOCTOR_CANDIDATE_ENTRY_TYPE } from "./dossier-resolution.ts";
-import {
-  readActivationEngineLaborFallbackField,
-  withEngineLaborFallbackField,
-} from "./engine-labor-fallback.ts";
 import { DOCTOR_EVIDENCE_TOOL_NAME, DOCTOR_OUTPUT_TOOL_DESCRIPTION, DOCTOR_OUTPUT_TOOL_NAME, DoctorEvidenceStore, doctorEvidenceReadSchema, doctorSubmissionSchema, validateDoctorOutput, type DoctorCase } from "./doctor-contracts.ts";
 
 export { DOCTOR_EVIDENCE_TOOL_NAME, DOCTOR_OUTPUT_TOOL_NAME };
@@ -16,7 +12,7 @@ export function createDoctorRoleRuntime(pi: ExtensionAPI, dependencies: DoctorRo
   let activation: { soul: string; patient: DoctorCase; store: DoctorEvidenceStore } | undefined; let registered = false; pi.registerFlag(DOCTOR_CASE_FLAG.name, DOCTOR_CASE_FLAG.definition);
   return { async activate() { const path = pi.getFlag(DOCTOR_CASE_FLAG.name); if (typeof path !== "string" || !path.trim()) throw new Error("Doctor requires --ak-doctor-case"); const soul = (await dependencies.loadSoul()).trim(); if (!soul) throw new Error("Doctor soul is empty"); const patient = await dependencies.loadCase(path); activation = { soul, patient, store: new DoctorEvidenceStore(patient) };
     if (!registered) { registered = true; pi.registerTool({ name: DOCTOR_EVIDENCE_TOOL_NAME, label: "Doctor Evidence", description: "Read retained Pi session bytes with bounded pagination.", parameters: doctorEvidenceReadSchema, async execute(_id, params: { evidenceId: string; offset?: number; limit?: number }) { if (!activation) throw new Error("Doctor is not activated"); const details = activation.store.read(params.evidenceId, params.offset, params.limit); return { content: [{ type: "text" as const, text: JSON.stringify(details) }], details }; } });
-      pi.registerTool({ name: DOCTOR_OUTPUT_TOOL_NAME, label: "Doctor Output", description: DOCTOR_OUTPUT_TOOL_DESCRIPTION, parameters: doctorSubmissionSchema, async execute(id, params, signal, _update, ctx): Promise<AgentToolResult<unknown>> { if (!activation) throw new Error("Doctor is not activated"); singleton(id, ctx); const testimony = validateDoctorOutput(params, activation.patient, activation.store); try { appendActiveSessionCustomEntry(ctx, DOCTOR_CANDIDATE_ENTRY_TYPE, { version: 1, testimony, readRecord: activation.store.readRecord(), patientIdentity: activation.patient.identity }, { unavailable: "doctor candidate retention is unavailable", failed: "doctor candidate retention failed" }); } catch (error) { host.failInfrastructure(error, ctx, id); } let audit: ComplianceDecision; try { audit = await dependencies.auditCompliance(signal === undefined ? { context: ctx } : { context: ctx, signal }); } catch (error) { host.failInfrastructure(error, ctx, id); } const details = testimony.status === "completed" ? { ...testimony, cost: activation.patient.cost } : testimony; const acceptedDetails = withEngineLaborFallbackField(details, readActivationEngineLaborFallbackField()); return disposeComplianceDecision<AgentToolResult<unknown>>(audit, { pass: (usage) => ({ content: [{ type: "text" as const, text: "Doctor output accepted" }], details: acceptedDetails, terminate: true as const, ...(usage === undefined ? {} : { usage }) }), noReceipt: (auditNoReceipt, usageProjection) => ({ content: [{ type: "text" as const, text: "Doctor output accepted; compliance audit produced no receipt" }], details: { ...acceptedDetails, auditNoReceipt }, terminate: true as const, ...usageProjection }), revise: (violations) => { throw new Error(`Doctor output violates its soul: ${violations.join("; ")}`); }, escalate: (result) => result, auditIncomplete: (result) => result }, acceptedDetails); } });
+      pi.registerTool({ name: DOCTOR_OUTPUT_TOOL_NAME, label: "Doctor Output", description: DOCTOR_OUTPUT_TOOL_DESCRIPTION, parameters: doctorSubmissionSchema, async execute(id, params, signal, _update, ctx): Promise<AgentToolResult<unknown>> { if (!activation) throw new Error("Doctor is not activated"); singleton(id, ctx); const testimony = validateDoctorOutput(params, activation.patient, activation.store); try { appendActiveSessionCustomEntry(ctx, DOCTOR_CANDIDATE_ENTRY_TYPE, { version: 1, testimony, readRecord: activation.store.readRecord(), patientIdentity: activation.patient.identity }, { unavailable: "doctor candidate retention is unavailable", failed: "doctor candidate retention failed" }); } catch (error) { host.failInfrastructure(error, ctx, id); } let audit: ComplianceDecision; try { audit = await dependencies.auditCompliance(signal === undefined ? { context: ctx } : { context: ctx, signal }); } catch (error) { host.failInfrastructure(error, ctx, id); } const details = testimony.status === "completed" ? { ...testimony, cost: activation.patient.cost } : testimony; const acceptedDetails = details; return disposeComplianceDecision<AgentToolResult<unknown>>(audit, { pass: (usage) => ({ content: [{ type: "text" as const, text: "Doctor output accepted" }], details: acceptedDetails, terminate: true as const, ...(usage === undefined ? {} : { usage }) }), noReceipt: (auditNoReceipt, usageProjection) => ({ content: [{ type: "text" as const, text: "Doctor output accepted; compliance audit produced no receipt" }], details: { ...acceptedDetails, auditNoReceipt }, terminate: true as const, ...usageProjection }), revise: (violations) => { throw new Error(`Doctor output violates its soul: ${violations.join("; ")}`); }, escalate: (result) => result }, acceptedDetails); } });
       pi.on("before_agent_start", (event) => { if (!activation) throw new Error("Doctor is not activated"); const catalog = { version: activation.patient.version, identity: activation.patient.identity, admittedMetrics: { provenance: "runtime-derived from retained session bytes and sealed into the accepted receipt", cost: activation.patient.cost }, lawfulTargetKeys: ["case", ...activation.patient.cost.invocations.sources], evidence: activation.patient.evidence.map(({ id, kind, sha256, byteLength, contentLength }) => ({ id, kind, sha256, byteLength, contentLength })) }; return { systemPrompt: `${event.systemPrompt}\n\n<doctor_soul>\n${activation.soul}\n</doctor_soul>\n\n<doctor_case>\n${JSON.stringify(catalog)}\n</doctor_case>` }; }); }
     const required = [DOCTOR_EVIDENCE_TOOL_NAME, DOCTOR_OUTPUT_TOOL_NAME]; const names = pi.getAllTools().map((tool) => tool.name); for (const name of required) if (names.filter((item) => item === name).length !== 1) throw new Error(`Doctor required tool collision or missing: ${name}`); pi.setActiveTools(required); const active = pi.getActiveTools?.() ?? required; if (active.length !== 2 || !required.every((name) => active.includes(name))) throw new Error("Doctor active tool narrowing failed"); } };
 }

package/src/dossier-resolution.ts

@@ -130,8 +130,29 @@ export function readDoctorAuditSubjects(context: ExtensionContext): SubjectResol
   return { status: "incomplete", observation: { kind: "missing-subject", subject: "candidate-testimony" } };
 }
 
-export function toAuditIncomplete<TObservation extends DossierObservation>(
-  observation: TObservation,
-): { status: "audit-incomplete"; observation: TObservation; candidate: undefined } {
-  return { status: "audit-incomplete", observation, candidate: undefined };
+/**
+ * Missing dossier/subject is infrastructure failure, not a judgment status (#475).
+ * Observation + empty candidate ride the existing failInfrastructure → error artifact path.
+ */
+export class AuditMaterialsUnavailableError extends Error {
+  readonly observation: DossierObservation;
+  readonly candidate: undefined;
+  constructor(observation: DossierObservation) {
+    const detail =
+      observation.kind === "missing-subject"
+        ? `${observation.kind}:${observation.subject}`
+        : observation.kind;
+    super(`Audit materials unavailable: ${detail}`);
+    this.name = "AuditMaterialsUnavailableError";
+    this.observation = observation;
+    this.candidate = undefined;
+  }
+}
+
+export function requireAuditMaterials(
+  resolution: DossierResolution | SubjectResolution,
+): asserts resolution is DossierOk | SubjectOk {
+  if (resolution.status === "incomplete") {
+    throw new AuditMaterialsUnavailableError(resolution.observation);
+  }
 }

package/src/engine-detour-tool.ts

@@ -2,9 +2,8 @@
  * Package-owned engine detour tool (#357 T2 / #378 / #380).
  * Registered by shared role-runtime when any role + 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.
+ * Engine process failures stop through the host infrastructure-failure seam.
+ * Caller AbortSignal cancellation propagates unchanged.
  */
 import type {
   AgentToolResult,
@@ -22,11 +21,6 @@ import {
   isEngineDetourFailure,
   runEngineDetourOnce,
 } from "./engine-detour.ts";
-import {
-  activationEngineLaborFallbackLatch,
-  recordEngineLaborFallback,
-  type EngineLaborFallbackField,
-} from "./engine-labor-fallback.ts";
 
 const engineDetourArgsSchema = Type.Object(
   {
@@ -56,27 +50,7 @@ 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; process failure is seat-fallback, not cancel. */
+/** Caller/upper-layer cancellation must propagate unchanged. */
 function isCallerCancellation(
   error: unknown,
   signal: AbortSignal | undefined,
@@ -96,8 +70,8 @@ function isCallerCancellation(
  * 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) for tool misuse only.
- * Engine process failure (nonzero/empty/spawn) soft-returns seat fallback (#380).
- * Caller AbortSignal cancel propagates without writing fallback.
+ * Engine process failures (nonzero/empty/spawn) stop via `fail` with their cause.
+ * Caller AbortSignal cancellation propagates unchanged.
  */
 export function createEngineDetourToolDefinition(input: {
   engineName: string;
@@ -116,7 +90,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.",
+      "An engine process failure stops this activation; do not continue labor in this session.",
     ],
     parameters: engineDetourArgsSchema,
     async execute(
@@ -145,17 +119,6 @@ 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 {
         result = await runEngineDetourOnce({
@@ -164,17 +127,19 @@ export function createEngineDetourToolDefinition(input: {
           ...(signal === undefined ? {} : { signal }),
         });
       } catch (error) {
-        // Caller cancel: propagate. 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 (isCallerCancellation(error, signal)) throw error;
+        const cause = error instanceof Error
+          ? error
+          : new Error(String(error).trim() || "engine detour spawn failed");
+        input.fail(cause, toolCallId, ctx);
       }
 
       if (isEngineDetourFailure(result)) {
-        return softFail(engineDetourFailureDiagnostic(result));
+        input.fail(
+          new Error(engineDetourFailureDiagnostic(result)),
+          toolCallId,
+          ctx,
+        );
       }
 
       return {

package/src/evidence-child-executor.ts

@@ -610,15 +610,17 @@ export async function executeEvidenceChild(
                 engine: engineName,
                 packageRoot: options.packageRoot,
               });
-      // #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.
+      // Evidence legs use the parent detour tool; retain any engine process cause
+      // so the enclosing child boundary, rather than a tool-error result, terminates.
+      let engineDetourFailure: Error | undefined;
       const engineDetourTool =
         engineName === undefined
           ? undefined
           : createEngineDetourToolDefinition({
               engineName,
               fail(error) {
-                throw error instanceof Error ? error : new Error(String(error));
+                engineDetourFailure ??= error instanceof Error ? error : new Error(String(error));
+                throw engineDetourFailure;
               },
             });
       // No tools allowlist — Pi defaults + unrestricted evidence surface (ADR 0064).
@@ -654,8 +656,14 @@ export async function executeEvidenceChild(
         try {
           await session.prompt(delivered);
         } catch (error) {
+          if (engineDetourFailure !== undefined) {
+            throw classifiedError(engineDetourFailure, "child");
+          }
           throw classifiedError(error, "provider");
         }
+        if (engineDetourFailure !== undefined) {
+          throw classifiedError(engineDetourFailure, "child");
+        }
         if (signal?.aborted) throw new Error("Evidence child was cancelled");
         const lastAssistant = [...session.messages]
           .reverse()
@@ -927,7 +935,7 @@ export async function executeAuditorChild(
               decision = part.arguments;
               decisionCallId = part.id;
               // Pi can reject malformed root arguments before invoking execute;
-              // that remains the existing typed audit-incomplete candidate path.
+              // that remains the existing unreadable-candidate failure path.
               if (part.arguments === undefined) decisionSubmitted = true;
             }
           }

package/src/factory-board.ts

@@ -20,7 +20,6 @@ import { randomUUID } from "node:crypto";
 import { lstat, mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 
-import { seatFallbackBaseStatus } from "./engine-labor-fallback.ts";
 import {
   formatDurationZh,
   formatLocalDateTime,
@@ -177,8 +176,7 @@ export function decideTicketCurrentState(input: {
   const latest = sortRunsByStart(input.runs).at(-1)!;
   if (!latest.hasResult) return unacceptedBand(latest.mtimeMs, input.now.getTime());
   // Escalate is an awaiting overlay: same placement and sort band, distinct state.
-  // Seat-fallback taint (`escalate-by-fallback`) keeps escalate base semantics.
-  if (seatFallbackBaseStatus(latest.resultStatus) === "escalate") return "escalate-awaiting";
+  if ((latest.resultStatus) === "escalate") return "escalate-awaiting";
   return "accepted-awaiting";
 }
 
@@ -847,7 +845,7 @@ function buildBreadcrumbSteps(runs: readonly TicketTrajectoryRun[]): BreadcrumbS
     const isRejected = group.runs.some(
       (run) =>
         run.hasResult &&
-        REJECTED_RESULT_STATUSES.has(seatFallbackBaseStatus(run.resultStatus)),
+        REJECTED_RESULT_STATUSES.has((run.resultStatus)),
     );
     steps.push({
       station: group.station,