@akagilnc/pi-workflow-roles 0.1.3572 → 0.1.3621

package/src/navigator-attendance.ts

@@ -16,7 +16,7 @@ import {
   resolveActivationLedgerHome,
 } from "./activation-ledger-topology.ts";
 import type { HostContext } from "./host-contracts.ts";
-import { createNativeNavigatorSessionFactory } from "./evidence-child-executor.ts";
+import { createNativeNavigatorSessionFactory } from "./navigator-public-session.ts";
 import {
   NAVIGATOR_DEFAULT_MODEL,
   NAVIGATOR_PREPARE_TOOL_NAME,
@@ -78,7 +78,9 @@ export function resolveNavigatorAuthorityMaterial(
   return undefined;
 }
 
-export const NAVIGATOR_TARGETS = PACKAGED_ROLE_REGISTRY.map(({ role, phases }) => ({ role, phases }));
+/** Every public role is a lawful navigator route target (#675 — no nested-only seats). */
+export const NAVIGATOR_TARGETS = PACKAGED_ROLE_REGISTRY
+  .map(({ role, phases }) => ({ role, phases }));
 
 export type NavigatorTargetRole = PackagedRole;
 export type NavigatorPhase = "plan" | "apply" | null;
@@ -591,11 +593,7 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
       const modelPromise = (async () => {
         try {
           // Same resolution authority as createNativeNavigatorSessionFactory (#590).
-          const resolved = await resolveNavigatorSeatSelection(
-            options.context,
-            options.modelSettingPath,
-            options.modelSettingPath ?? navigatorModelSettingPath(),
-          );
+          const resolved = await resolveNavigatorSeatSelection(options.context);
           return resolved.configuredLabel;
         } catch (error) {
           if (error instanceof NavigatorUnavailableError) throw error;
@@ -735,6 +733,14 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
               return;
             }
             if (promptFailure !== undefined) throw promptFailure;
+            const sessionNoReceipt = activeSession.noReceipt?.();
+            if (sessionNoReceipt !== undefined) {
+              // This session already settled without an accepted receipt on its own
+              // budget; one more prompt opens an independent summon, not a delivery
+              // request on the settled session (#675).
+              delivery.recordNestedNoReceipt(sessionNoReceipt);
+              return;
+            }
             if (deliveryRequest && output === undefined) delivery.recordDeliveryRequest();
           };
           await promptAllowingRejectedPrepare(request, false);
@@ -831,6 +837,8 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
   };
 
   async function settleOnce(settlement: NavigatorSettlement): Promise<void> {
+      // Dispose during post-role grace must ignore late completion entirely (#675).
+      if (disposed) return;
       const invocationId = activeInvocationId ?? invocationPrincipal;
       let report: NavigatorReport;
       if (settlement.kind === "human_decision" || settlement.kind === "role_infrastructure_failure") {
@@ -876,8 +884,10 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
           // table. After selection (speculative or rebound), advice is passed
           // through as-is (ADR 0010 / ADR 0061: caller may ignore).
           if (selected?.candidate.next !== undefined && !selected.matchedToSettlement) {
+            if (disposed) return;
             prepareBoundSettlement = settlement;
             prepared = await prepare();
+            if (disposed) return;
             selected = selectNavigatorCandidate(prepared, settlement);
           }
           // Budget exhaustion is affirmative typed no-advice; malformed submitted
@@ -933,10 +943,16 @@ export function createNavigatorAttendance(options: NavigatorAttendanceOptions) {
         ...(report.routePlaybookReadFailure === undefined ? {} : { routePlaybookReadFailure: report.routePlaybookReadFailure }),
         ...(report.arrivalMessage === undefined ? {} : { arrivalMessage: report.arrivalMessage }),
       };
-      // Dispose during post-role grace must ignore late completion (ADR 0052 / #106).
+      // Dispose during post-role grace must ignore late completion (ADR 0052 / #106 / #675).
       // Every settled disposition (recommendation | no-advice | unavailable | arrival) is affirmative.
-      if (!disposed) {
+      // Only the disposed bit is typed authority to drop — never match free-text Error.message.
+      if (disposed) return;
+      try {
         await options.onEvent(event, report);
+      } catch (error) {
+        // Race: dispose landed between the check and onEvent; drop only then.
+        if (disposed) return;
+        throw error;
       }
       preparation = undefined;
       sessionReady = undefined;

package/src/navigator-public-session.ts

@@ -0,0 +1,217 @@
+/**
+ * Navigator attendance session factory (#675 r3).
+ * Each prepare turn uses the public navigator activation path (summonPublicRole) —
+ * same seat table and shared envelope as `ak-role navigator`.
+ * Archivist createRecordSession only books route-memory nest under the parent;
+ * no openPiInProcessSession second lifecycle / no agentDir patch on the old path.
+ */
+import { sitianReport } from "./sitian-facade.ts";
+import {
+  NavigatorUnavailableError,
+  navigatorProviderFailureFromDiagnostics,
+  navigatorProviderFailureFromError,
+  navigatorProviderFailureFromStatus,
+  navigatorUnavailableError,
+  parseNavigatorModelSetting,
+  resolveNavigatorSeatSelection,
+  type NavigatorProviderFailureFact,
+  type NavigatorSessionFactory,
+} from "./navigator-session-contracts.ts";
+import type { NoReceiptLifecycleFacts } from "./receipt-delivery-policy.ts";
+
+/**
+ * Classify public-navigator failure terminal from structured decisiveFacts only
+ * (httpStatus / diagnostics / secondaryEvidence on the terminal) — same fields
+ * settlement already stamps from typed HTTP observation / provider stop.
+ */
+function providerFailureFromPublicTerminal(outcome: {
+  readonly cause: string;
+  readonly diagnostic: string;
+  readonly decisiveFacts: Readonly<Record<string, unknown>>;
+}): NavigatorProviderFailureFact {
+  const facts = outcome.decisiveFacts;
+  const secondary =
+    typeof facts.secondaryEvidence === "object" && facts.secondaryEvidence !== null
+      ? (facts.secondaryEvidence as Record<string, unknown>)
+      : undefined;
+  const httpStatus =
+    typeof secondary?.httpStatus === "number"
+      ? secondary.httpStatus
+      : typeof facts.httpStatus === "number"
+        ? facts.httpStatus
+        : typeof facts.errorCode === "number"
+          ? facts.errorCode
+          : undefined;
+  const fromStatus = navigatorProviderFailureFromStatus(httpStatus);
+  if (fromStatus !== undefined) return fromStatus;
+  const diagnostics = secondary?.diagnostics ?? facts.diagnostics;
+  const fromDiagnostics = navigatorProviderFailureFromDiagnostics(diagnostics);
+  if (fromDiagnostics !== undefined) return fromDiagnostics;
+  const fromCode = navigatorProviderFailureFromError({
+    code: secondary?.code ?? facts.errorCode,
+  });
+  if (fromCode !== undefined) return fromCode;
+  if (outcome.cause === "provider") return { source: "transport", cause: "transport" };
+  return { source: "session", cause: "session" };
+}
+
+export function createNativeNavigatorSessionFactory(): NavigatorSessionFactory {
+  return async ({ context, subject, tool }) => {
+    const resolved = await resolveNavigatorSeatSelection(context);
+    let thinkingLevel = resolved.thinkingLevel;
+
+    // Archivist nest for attendance route memory only (ADR 0018 / 0065) — not a session open.
+    const { createRecordSession } = await import("./archivist-record-entry.ts");
+    const sessionManager = createRecordSession({
+      cwd: context.cwd,
+      kind: "navigator",
+      subject,
+      parent: context.sessionManager,
+    });
+
+    let providerFailure: NavigatorProviderFailureFact | undefined;
+    let noReceipt: NoReceiptLifecycleFacts | undefined;
+    let disposed = false;
+    let inFlightPrompt: Promise<unknown> | undefined;
+
+    const resolveHome = async (): Promise<string | undefined> => {
+      const parentFile = context.sessionManager?.getSessionFile?.();
+      if (typeof parentFile === "string" && parentFile.trim() !== "") {
+        try {
+          const { tryHomeFromAkRolesPath, homeFromRunDirectory } = await import(
+            "./activation-ledger-topology.ts"
+          );
+          const fromParent = tryHomeFromAkRolesPath(parentFile);
+          if (fromParent !== undefined && fromParent.length > 0) return fromParent;
+          const runDir = parentFile.replace(/\/session\/session\.jsonl$/, "");
+          if (runDir !== parentFile) {
+            try {
+              return homeFromRunDirectory(runDir);
+            } catch {
+              // fall through
+            }
+          }
+        } catch {
+          // fall through
+        }
+      }
+      const envHome = process.env.HOME;
+      return typeof envHome === "string" && envHome.trim() !== "" ? envHome : undefined;
+    };
+
+    return {
+      prompt: async (text) => {
+        if (disposed) {
+          throw navigatorUnavailableError("session", new Error("Navigator attendance was disposed"));
+        }
+        providerFailure = undefined;
+        noReceipt = undefined;
+        const run = (async () => {
+        try {
+          const { summonPublicRole } = await import("./public-role-summons.ts");
+          const home = await resolveHome();
+          // Public activation — same face as `ak-role navigator <instruction>` (#675).
+          const summoned = await summonPublicRole({
+            role: "navigator",
+            argv: [text],
+            cwd: context.cwd,
+            ...(home === undefined ? {} : { home }),
+          });
+
+          const outcome = summoned.terminal?.roleOutcome;
+          if (outcome === undefined) {
+            const detail = summoned.stderr?.trim() || `exit ${summoned.exitCode}`;
+            providerFailure = { source: "transport", cause: "transport" };
+            throw navigatorUnavailableError(
+              "transport",
+              new Error(`Navigator public summon produced no terminal (${detail})`),
+            );
+          }
+          if (outcome.kind === "failure") {
+            providerFailure = providerFailureFromPublicTerminal(outcome);
+            throw navigatorUnavailableError(
+              providerFailure.source,
+              new Error(outcome.diagnostic),
+              providerFailure.cause,
+            );
+          }
+          if (outcome.kind === "no_receipt") {
+            // The nested session spent its own delivery budget; attendance settles
+            // no-receipt on these facts instead of opening another summon (#675).
+            noReceipt = outcome;
+            return;
+          }
+          if (outcome.kind !== "accepted") {
+            providerFailure = { source: "session", cause: "session" };
+            throw navigatorUnavailableError(
+              "session",
+              new Error("Navigator public summon returned unusable terminal"),
+            );
+          }
+          const candidates = outcome.decisiveFacts.candidates;
+          if (!Array.isArray(candidates)) {
+            return;
+          }
+          // Rejoin attendance prepare tool sink (same candidate shape as public advice).
+          await tool.execute(
+            "navigator-public-prepare",
+            { candidates },
+            undefined,
+            undefined,
+            context as never,
+          );
+        } catch (error) {
+          if (error instanceof NavigatorUnavailableError) throw error;
+          const fact = navigatorProviderFailureFromError(error);
+          providerFailure = fact ?? { source: "transport", cause: "transport" };
+          throw navigatorUnavailableError(providerFailure.source, error, providerFailure.cause);
+        }
+        })();
+        inFlightPrompt = run;
+        try {
+          await run;
+        } finally {
+          if (inFlightPrompt === run) inFlightPrompt = undefined;
+        }
+      },
+      providerFailure: () => providerFailure,
+      noReceipt: () => noReceipt,
+      appendEntry: (customType, data) => {
+        sessionManager.appendCustomEntry(customType, data);
+        try {
+          sitianReport({
+            level: "event",
+            kind: "attendance",
+            cwd: context.cwd,
+            sessionParent: sessionManager.getSessionFile(),
+            payload: { customType, data },
+            source: "navigator-public-session",
+          });
+        } catch {
+          // best-effort
+        }
+      },
+      entries: () => sessionManager.getEntries(),
+      setModel: async (next, nextThinking) => {
+        let nextParsed: ReturnType<typeof parseNavigatorModelSetting>;
+        try {
+          nextParsed = parseNavigatorModelSetting(next);
+        } catch (error) {
+          throw navigatorUnavailableError("model", error);
+        }
+        // No live provider session is pinned here: every prompt is an independent
+        // public summon whose nested CLI reads the current seat table (#675 验收②
+        // / #617 DK-3). A seat edit between prepares therefore applies on the next
+        // summon — it is never an unavailable session.
+        thinkingLevel = nextThinking ?? nextParsed.thinkingLevel;
+      },
+      getThinkingLevel: () => thinkingLevel,
+      recordPointer: () => sessionManager.getSessionDir(),
+      dispose: async () => {
+        disposed = true;
+        const pending = inFlightPrompt;
+        if (pending !== undefined) await pending.catch(() => undefined);
+      },
+    };
+  };
+}

package/src/navigator-session-contracts.ts

@@ -10,12 +10,9 @@ import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 
-import { auditorRunDirectory } from "./auditor-dossier-tool.ts";
 import type { HostContext, HostInstitutionalModelSelection } from "./host-contracts.ts";
-import {
-  InstitutionalResolutionError,
-  readInstitutionalSeatSelection,
-} from "./institutional-resolution.ts";
+import type { NoReceiptLifecycleFacts } from "./receipt-delivery-policy.ts";
+
 
 export const NAVIGATOR_PREPARE_TOOL_NAME = "ak_navigator_prepare" as const;
 export const NAVIGATOR_DEFAULT_MODEL = "openai-codex/gpt-5.6-luna:max" as const;
@@ -162,6 +159,12 @@ export type NavigatorPreparationSession = {
   appendEntry(customType: string, data: unknown): void;
   entries(): readonly unknown[];
   providerFailure?(): NavigatorProviderFailureFact | undefined;
+  /**
+   * Facts of a nested session that already settled without an accepted receipt.
+   * Present means its own delivery budget is spent — another prompt would open an
+   * independent summon rather than press the session that owes the receipt.
+   */
+  noReceipt?(): NoReceiptLifecycleFacts | undefined;
   setModel?(model: string, thinkingLevel?: string): Promise<void>;
   getThinkingLevel?(): string | undefined;
   recordPointer(): string;
@@ -204,6 +207,7 @@ export async function writeNavigatorModelSetting(model: string, path = navigator
 export function parseNavigatorModelSetting(value: string): {
   provider: string;
   model: string;
+  /** Host thinking passthrough — omit when bare provider/model (#675 ⑥). */
   thinkingLevel?: string;
 } {
   const slash = value.indexOf("/");
@@ -216,68 +220,71 @@ export function parseNavigatorModelSetting(value: string): {
   const suffix = colon < 0 ? undefined : modelWithThinking.slice(colon + 1);
   const model = colon < 0 ? modelWithThinking : modelWithThinking.slice(0, colon);
   if (model === "") throw new Error("Navigator model setting must include a model");
-  // Suffix is opaque pass-through; bare provider/model omits thinkingLevel (Pi default).
-  return suffix === undefined
-    ? { provider, model }
-    : { provider, model, thinkingLevel: suffix };
+  if (suffix !== undefined && suffix.trim() === "") {
+    throw new Error("Navigator model setting thinking suffix must be non-blank");
+  }
+  return {
+    provider,
+    model,
+    ...(suffix === undefined ? {} : { thinkingLevel: suffix }),
+  };
 }
 
 /**
- * Prefer institutional-resolution navigator seat; fall back to model file only when
- * the page is missing or lacks the seat (typed reasons). Corrupted pages fail loud.
+ * Navigator model selection from the public seat table only (#675 / #617 DK-3).
+ * No legacy navigator-model.json fallback — missing seat is a real model failure.
+ * Host/engine axes ride the shared public summons path; attendance open consumes
+ * model/thinking here and defers host selection to the shared envelope when present.
  */
 export async function resolveNavigatorSeatSelection(
   context: HostContext,
-  modelSettingPath: string | undefined,
-  defaultModelSettingPath: string,
 ): Promise<{ selection: HostInstitutionalModelSelection; configuredLabel: string; thinkingLevel?: string }> {
-  const runDirectory = auditorRunDirectory(context);
-  if (runDirectory !== undefined) {
-    try {
-      const selection = await readInstitutionalSeatSelection(runDirectory, "navigator");
+  try {
+    const { loadPublicCliConfig } = await import("./public-cli/config.ts");
+    const { seatModelOnly } = await import("./public-cli/registry.ts");
+    const { packageMachineHome } = await import("./activation-ledger-topology.ts");
+    const homeCandidate = (context as unknown as { home?: unknown }).home;
+    const envHome = process.env.HOME;
+    // Prefer explicit context home, then process HOME (hermetic tests), never
+    // jump straight to the real machine home when a temp HOME is armed.
+    const home =
+      typeof homeCandidate === "string"
+        ? homeCandidate
+        : typeof envHome === "string" && envHome.trim() !== ""
+          ? envHome
+          : packageMachineHome();
+    const config = await loadPublicCliConfig(home);
+    const modelOnly = seatModelOnly(config.seats.navigator);
+    // Seat table is the only model authority — no legacy navigator-model.json.
+    // Bare missing seat uses the package default constant (not a file path).
+    if (modelOnly === undefined) {
+      const parsed = parseNavigatorModelSetting(NAVIGATOR_DEFAULT_MODEL);
       return {
         selection: {
-          provider: selection.provider,
-          model: selection.model,
-          ...(selection.thinking === undefined ? {} : { thinking: selection.thinking }),
+          provider: parsed.provider,
+          model: parsed.model,
+          ...(parsed.thinkingLevel === undefined ? {} : { thinking: parsed.thinkingLevel }),
         },
-        configuredLabel: selection.thinking === undefined
-          ? `${selection.provider}/${selection.model}`
-          : `${selection.provider}/${selection.model}:${selection.thinking}`,
-        ...(selection.thinking === undefined ? {} : { thinkingLevel: selection.thinking }),
+        configuredLabel: NAVIGATOR_DEFAULT_MODEL,
+        ...(parsed.thinkingLevel === undefined ? {} : { thinkingLevel: parsed.thinkingLevel }),
       };
-    } catch (error) {
-      if (
-        error instanceof InstitutionalResolutionError
-        && (error.reason === "missing-page" || error.reason === "missing-seat")
-      ) {
-        // documented bare-seam fallback
-      } else {
-        throw error instanceof NavigatorUnavailableError
-          ? error
-          : navigatorUnavailableError("model", error);
-      }
     }
-  }
-  let configured: string;
-  try {
-    configured = await readNavigatorModelSetting(modelSettingPath ?? defaultModelSettingPath);
+    // Host params passthrough only — no map/validate/default (#675 ⑥).
+    const thinkingRaw = modelOnly.thinking;
+    const configuredLabel =
+      thinkingRaw === undefined
+        ? `${modelOnly.provider}/${modelOnly.model}`
+        : `${modelOnly.provider}/${modelOnly.model}:${thinkingRaw}`;
+    return {
+      selection: {
+        provider: modelOnly.provider,
+        model: modelOnly.model,
+        ...(thinkingRaw === undefined ? {} : { thinking: thinkingRaw }),
+      },
+      configuredLabel,
+      ...(thinkingRaw === undefined ? {} : { thinkingLevel: thinkingRaw }),
+    };
   } catch (error) {
     throw navigatorUnavailableError("model", error);
   }
-  let parsed: ReturnType<typeof parseNavigatorModelSetting>;
-  try {
-    parsed = parseNavigatorModelSetting(configured);
-  } catch (error) {
-    throw navigatorUnavailableError("model", error);
-  }
-  return {
-    selection: {
-      provider: parsed.provider,
-      model: parsed.model,
-      ...(parsed.thinkingLevel === undefined ? {} : { thinking: parsed.thinkingLevel }),
-    },
-    configuredLabel: configured,
-    ...(parsed.thinkingLevel === undefined ? {} : { thinkingLevel: parsed.thinkingLevel }),
-  };
 }

package/src/notary-source-run.ts

@@ -15,8 +15,10 @@ import {
 import type { NotarySourceRunLocator } from "./notary-contracts.ts";
 import { readRoleRunIdentity } from "./public-cli/run-lifecycle.ts";
 
+// Run directory leaf: <runId>@<role>. Production uses uuidv7 runIds; offline tracers
+// may use deterministic non-uuid leaves. Role token stays identifier-shaped.
 const RUN_DIR_NAME =
-  /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})@([A-Za-z][A-Za-z0-9_-]*)$/i;
+  /^([A-Za-z0-9][A-Za-z0-9._-]*)@([A-Za-z][A-Za-z0-9_-]*)$/;
 
 export class NotarySourceRunError extends Error {
   constructor(message: string, options?: ErrorOptions) {

package/src/package-contracts/auditor-output.ts

@@ -0,0 +1,82 @@
+/**
+ * Public Auditor (审刑院) terminating receipt contracts (#675).
+ * Lawful explicit releases: pass | revise | escalate.
+ */
+import { Type } from "typebox";
+
+import { openToolObject } from "../open-tool-schema.ts";
+import { withInfrastructureFailureDeclaration } from "./terminating-infrastructure.ts";
+
+export const AUDITOR_OUTPUT_TOOL_NAME = "ak_auditor_output" as const;
+export const AUDITOR_ACCEPTED_TEXT = "审刑院回执已接受";
+
+export const auditorOutputSchema = withInfrastructureFailureDeclaration(
+  openToolObject(
+    Type.Object({
+      status: Type.Unknown({
+        description: "pass | revise | escalate — 形状指引，非 schema 闸",
+      }),
+      violations: Type.Optional(Type.Unknown({
+        description: "status 为 revise 时的违规条目",
+      })),
+      conflicts: Type.Optional(Type.Unknown({
+        description: "status 为 escalate 时的冲突",
+      })),
+      decisionGate: Type.Optional(Type.Unknown({
+        description: "status 为 escalate 时的决策闸",
+      })),
+    }),
+  ),
+);
+
+export type AuditorOutput =
+  | { readonly status: "pass" }
+  | { readonly status: "revise"; readonly violations?: unknown }
+  | {
+      readonly status: "escalate";
+      readonly conflicts?: unknown;
+      readonly decisionGate?: unknown;
+    };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function projectLawfulAuditorOutput(value: unknown): AuditorOutput | undefined {
+  if (!isRecord(value)) return undefined;
+  if (value.status === "pass") return { status: "pass" };
+  if (value.status === "revise") {
+    return {
+      status: "revise",
+      ...(Object.hasOwn(value, "violations") ? { violations: value.violations } : {}),
+    };
+  }
+  if (value.status === "escalate") {
+    return {
+      status: "escalate",
+      ...(Object.hasOwn(value, "conflicts") ? { conflicts: value.conflicts } : {}),
+      ...(Object.hasOwn(value, "decisionGate") ? { decisionGate: value.decisionGate } : {}),
+    };
+  }
+  return undefined;
+}
+
+export function validateRecordedAuditorOutput(value: unknown): AuditorOutput {
+  const projected = projectLawfulAuditorOutput(value);
+  if (projected === undefined) {
+    throw new Error("Auditor output has no recognized execution discriminator");
+  }
+  return projected;
+}
+
+export function auditorDecisiveFacts(output: AuditorOutput): Record<string, unknown> {
+  const facts: Record<string, unknown> = { status: output.status };
+  if (output.status === "revise" && output.violations !== undefined) {
+    facts.violations = output.violations;
+  }
+  if (output.status === "escalate") {
+    if (output.conflicts !== undefined) facts.conflicts = output.conflicts;
+    if (output.decisionGate !== undefined) facts.decisionGate = output.decisionGate;
+  }
+  return facts;
+}

package/src/package-contracts/evidence-child-output.ts

@@ -0,0 +1,51 @@
+/**
+ * Public Evidence-Child terminating receipt contracts (#675).
+ * One report body; shape is not an admission gate (ADR 0055).
+ */
+import { Type } from "typebox";
+
+import { openToolObject } from "../open-tool-schema.ts";
+import { withInfrastructureFailureDeclaration } from "./terminating-infrastructure.ts";
+
+export const EVIDENCE_CHILD_OUTPUT_TOOL_NAME = "ak_evidence_child_output" as const;
+export const EVIDENCE_CHILD_ACCEPTED_TEXT = "取证回执已接受";
+
+export const evidenceChildOutputSchema = withInfrastructureFailureDeclaration(
+  openToolObject(
+    Type.Object({
+      report: Type.Unknown({
+        description: "取证报告正文 — 形状指引，非 schema 闸",
+      }),
+    }),
+  ),
+);
+
+/** Report body retained as delivered — no type/blank/field-presence reshape (ADR 0055 / §0). */
+export type EvidenceChildOutput = { readonly report: unknown };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function projectLawfulEvidenceChildOutput(
+  value: unknown,
+): EvidenceChildOutput | undefined {
+  // No field-presence gate (ADR 0055 / CLAUDE.md §0 / #675). Retain delivered bytes:
+  // report key when present, otherwise the whole object as the report body.
+  if (!isRecord(value)) return undefined;
+  return { report: Object.hasOwn(value, "report") ? value.report : value };
+}
+
+export function validateRecordedEvidenceChildOutput(value: unknown): EvidenceChildOutput {
+  const projected = projectLawfulEvidenceChildOutput(value);
+  if (projected === undefined) {
+    throw new Error("Evidence-child output is not an object");
+  }
+  return projected;
+}
+
+export function evidenceChildDecisiveFacts(
+  output: EvidenceChildOutput,
+): Record<string, unknown> {
+  return { report: output.report };
+}

package/src/package-contracts/judge-output.ts

@@ -4,6 +4,7 @@
 export const JUDGE_OUTPUT_TOOL_NAME = "ak_judge_output";
 export const JUDGE_ACCEPTED_TEXT = "大理寺回执已接受";
 export const JUDGE_ACCEPTED_AUDIT_NO_RECEIPT_TEXT = "大理寺回执已接受；审计无回执";
+export const JUDGE_ACCEPTED_AUDIT_UNREADABLE_TEXT = "大理寺回执已接受；审计形状不可读";
 
 export type JudgeClass = {
   name: string;

package/src/package-contracts/reviewer-output.ts

@@ -10,8 +10,8 @@ export type ReviewerAmendments = Readonly<Partial<Record<"standards" | "spec", s
 export type ReviewerIntent =
   | Readonly<{ status: "completed"; amendments?: ReviewerAmendments }>
   | Readonly<{ status: "refused"; diagnostic: string; amendments?: ReviewerAmendments }>;
-/** Child report is plain text — no length/digest identity shell (ADR 0031). */
-export type VerbatimChildReport = Readonly<{ text: string }>;
+/** Child report body retained as delivered — no type/blank reshape (ADR 0031 / 0055 / #675). */
+export type VerbatimChildReport = Readonly<{ text: unknown }>;
 /** Prompt projection on the receipt face is plain text (ADR 0031). */
 export type ReviewerReceiptPrompt = Readonly<{ text: string }>;
 /** Canonical Skill content on the receipt face is plain text (ADR 0031/0032). */