@akagilnc/pi-workflow-roles 0.1.2383 → 0.1.2397

package/dist/audit-escalation.js

@@ -69,14 +69,6 @@ export function projectAuditEscalation(decision, deliveredOutput) {
         ...(decision.usage === undefined ? {} : { usage: decision.usage }),
     };
 }
-export function projectAuditIncomplete(decision) {
-    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.
@@ -106,10 +98,5 @@ export async function disposeComplianceDecision(decision, handlers, deliveredOut
             return await handlers.revise(decision.violations);
         case "escalate":
             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/dist/compliance-transport.js

@@ -1,12 +1,34 @@
 import { Type } from "typebox";
 import { executeAuditorChild, } from "./evidence-child-executor.js";
 import { createAuditorDossierTool } from "./auditor-dossier-tool.js";
+/** Unreadable compliance candidate — infrastructure failure, not a judgment status (#475). */
+export class ComplianceCandidateUnreadableError extends Error {
+    observation;
+    candidate;
+    usage;
+    constructor(observation, candidate, 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;
+    }
+}
 /** Zero-projection kickoff — soul already carries dossier-fetch duty; no hand-delivered materials. */
 export const AUDITOR_DOSSIER_PROMPT = "Audit the current run dossier.";
 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, description) {
     return { name, description, parameters: complianceDecisionSchema, async execute(_id, params) { return { content: [{ type: "text", text: "Compliance decision received" }], details: params, terminate: true }; } };
@@ -48,8 +70,9 @@ function retainComplianceResponse(context, response) {
 }
 function readListField(value) { return Array.isArray(value) ? value : value === undefined ? [] : [value]; }
 export function readComplianceCandidate(arguments_, usage) {
-    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_ }, 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_ }, arguments_, usage);
+    }
     const args = arguments_;
     const status = args.status;
     if (status === "pass")
@@ -58,7 +81,7 @@ export function readComplianceCandidate(arguments_, usage) {
         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 async function runComplianceAudit(options) {
     const prompt = options.serializedInput ?? AUDITOR_DOSSIER_PROMPT;

package/dist/dossier-resolution.js

@@ -98,6 +98,25 @@ export function readDoctorAuditSubjects(context) {
     }
     return { status: "incomplete", observation: { kind: "missing-subject", subject: "candidate-testimony" } };
 }
-export function toAuditIncomplete(observation) {
-    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 {
+    observation;
+    candidate;
+    constructor(observation) {
+        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) {
+    if (resolution.status === "incomplete") {
+        throw new AuditMaterialsUnavailableError(resolution.observation);
+    }
 }

package/dist/evidence-child-executor.js

@@ -756,7 +756,7 @@ export async function executeAuditorChild(options) {
                             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/dist/navigator-invocation-identity.js

@@ -8,6 +8,13 @@ const NAVIGATOR_INFRASTRUCTURE_FAILURE_KEYS = [
   "source",
   "reasonCode"
 ];
+const NAVIGATOR_INFRASTRUCTURE_FAILURE_EVIDENCE_KEYS = [
+  "observation",
+  "candidate",
+  "submission",
+  "stage",
+  "reason"
+];
 function buildNavigatorInfrastructureFailureFact() {
   return {
     kind: NAVIGATOR_INFRASTRUCTURE_FAILURE_KIND,
@@ -15,16 +22,18 @@ function buildNavigatorInfrastructureFailureFact() {
     reasonCode: "host_failure"
   };
 }
-function isNavigatorInfrastructureFailureFact(value) {
+function hasNavigatorInfrastructureFailureBase(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   const record = value;
-  const keys = Object.keys(record);
-  if (keys.length !== NAVIGATOR_INFRASTRUCTURE_FAILURE_KEYS.length) return false;
   for (const key of NAVIGATOR_INFRASTRUCTURE_FAILURE_KEYS) {
     if (!Object.hasOwn(record, key)) return false;
   }
   return record.kind === NAVIGATOR_INFRASTRUCTURE_FAILURE_KIND && record.source === "shared-role-lifecycle" && record.reasonCode === "host_failure";
 }
+function isNavigatorInfrastructureFailureFact(value) {
+  if (!hasNavigatorInfrastructureFailureBase(value)) return false;
+  return Object.keys(value).length === NAVIGATOR_INFRASTRUCTURE_FAILURE_KEYS.length;
+}
 const PACKAGED_ROLE_OUTPUT_TOOLS = new Map(
   PACKAGED_ROLE_REGISTRY.map((entry) => [entry.outputTool, entry.role])
 );
@@ -68,7 +77,8 @@ function markerMatchesExpectedIdentity(marker, expected) {
 function classifyPackagedRoleTerminalResult(message) {
   if (typeof message.toolName !== "string") return { kind: "nonterminal" };
   if (!PACKAGED_ROLE_OUTPUT_TOOLS.has(message.toolName)) return { kind: "nonterminal" };
-  const infraFact = isNavigatorInfrastructureFailureFact(message.details) ? message.details : void 0;
+  const hasInfraBase = hasNavigatorInfrastructureFailureBase(message.details);
+  const infraFact = hasInfraBase ? buildNavigatorInfrastructureFailureFact() : void 0;
   if (message.isError === true) {
     if (infraFact === void 0) return { kind: "nonterminal" };
     return { kind: "infrastructure", fact: infraFact };
@@ -201,6 +211,7 @@ function currentInvocationMarkerFromSession(entries, beforeIndex = entries.lengt
   return void 0;
 }
 export {
+  NAVIGATOR_INFRASTRUCTURE_FAILURE_EVIDENCE_KEYS,
   NAVIGATOR_INFRASTRUCTURE_FAILURE_KIND,
   NAVIGATOR_INVOCATION_ENTRY,
   bindCurrentDurableTerminalToMarker,
@@ -209,6 +220,7 @@ export {
   currentInvocationMarkerFromSession,
   currentInvocationPrincipalFromSession,
   findLatestDurablePackagedRoleTerminal,
+  hasNavigatorInfrastructureFailureBase,
   isAcceptedPackagedRoleTerminalResult,
   isDurablePackagedRoleTerminalResult,
   isNavigatorInfrastructureFailureFact,

package/dist/notary-contracts.js

@@ -1,7 +1,7 @@
 /**
  * Public Notary (符宝郎) terminating receipt contracts.
- * Lawful explicit releases: pass | bounce | incomplete(with non-empty reason).
- * Residual incomplete (no explicit release) is projected by public settlement, not here.
+ * Lawful explicit releases: pass | bounce.
+ * No usable result is infrastructure failure via public settlement, not a judgment status (#475).
  */
 import { Type } from "typebox";
 import { readActivationEngineLaborFallbackField, seatFallbackBaseStatus, seatFallbackStatusHasLawfulEvidence, withEngineLaborFallbackField, } from "./engine-labor-fallback.js";
@@ -19,14 +19,11 @@ export const NOTARY_SOURCE_RUN_FLAG = {
 export const NOTARY_FIXED_KICKOFF = "Notary review. Bound source-run locator is on the session materials; fetch authoritative ticket, git, and dossier evidence yourself; submit one typed decision.";
 export const notaryOutputSchema = openToolObject(Type.Object({
     status: Type.Unknown({
-        description: "pass | bounce | incomplete — guidance, not a schema gate.",
+        description: "pass | bounce — guidance, not a schema gate.",
     }),
     findings: Type.Unknown({
         description: "string[] findings retained with pass or bounce.",
     }),
-    reason: Type.Unknown({
-        description: "Why the notary decision is incomplete.",
-    }),
 }));
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -38,7 +35,7 @@ function asStringArray(value) {
 }
 /**
  * Project one explicit Notary release. Throws when there is no lawful explicit
- * pass / bounce / incomplete(reason) — callers map that to residual incomplete.
+ * pass / bounce — callers map that to the existing non-zero failure channel.
  */
 export function validateNotaryOutput(value) {
     if (!isRecord(value)) {
@@ -49,13 +46,6 @@ export function validateNotaryOutput(value) {
         throw new Error("Notary output has no recognized execution discriminator");
     }
     const status = seatFallbackBaseStatus(statusRaw);
-    if (status === "incomplete") {
-        const reason = value.reason;
-        if (typeof reason !== "string" || reason.trim() === "") {
-            throw new Error("Notary incomplete requires a non-empty reason");
-        }
-        return structuredClone(value);
-    }
     if (status === "bounce") {
         const clone = structuredClone(value);
         if (clone.disposition === undefined)
@@ -89,8 +79,5 @@ export function notaryDecisiveFacts(output) {
     if (status === "bounce") {
         facts.disposition = "rewrite";
     }
-    if (status === "incomplete") {
-        facts.reason = output.reason;
-    }
     return facts;
 }

package/dist/package-contracts/terminating-tools.js

@@ -82,7 +82,7 @@ export function validateAcceptedDetails(toolName, details) {
         [COLLECTOR_OUTPUT_TOOL]: [],
         [DOCTOR_OUTPUT_TOOL_NAME]: ["completed", "refused"],
         [MERGER_OUTPUT_TOOL_NAME]: ["completed", "escalate"],
-        [NOTARY_OUTPUT_TOOL_NAME]: ["pass", "bounce", "incomplete"],
+        [NOTARY_OUTPUT_TOOL_NAME]: ["pass", "bounce"],
     };
     const collectorDiscriminator = toolName === COLLECTOR_OUTPUT_TOOL && Array.isArray(candidate?.groups);
     const baseDiscriminator = typeof discriminator === "string" ? seatFallbackBaseStatus(discriminator) : discriminator;