@akagilnc/pi-workflow-roles 0.1.3565 → 0.1.3621

package/dist/merger-git-state.js

@@ -0,0 +1,78 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { exactUtf8 } from "./exact-utf8.js";
+import { isFullGitObjectId } from "./git-object-id.js";
+const execFileAsync = promisify(execFile);
+async function git(cwd, args) {
+    const { stdout } = await execFileAsync("git", args, { cwd, encoding: "buffer", maxBuffer: 16 * 1024 * 1024 });
+    return new Uint8Array(stdout);
+}
+function line(bytes, label) {
+    const value = exactUtf8(bytes, label).trim();
+    if (!value)
+        throw new Error(`${label} is empty`);
+    return value;
+}
+function nulPaths(bytes, label) {
+    const raw = exactUtf8(bytes, label);
+    if (raw.length > 0 && !raw.endsWith("\0"))
+        throw new Error(`${label} is not NUL terminated`);
+    return raw.split("\0").filter(Boolean).sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
+}
+async function unmerged(cwd) {
+    const raw = exactUtf8(await git(cwd, ["ls-files", "-u", "-z"]), "Git unmerged index");
+    const paths = new Set();
+    for (const row of raw.split("\0")) {
+        if (!row)
+            continue;
+        const tab = row.indexOf("\t");
+        if (tab < 0 || tab === row.length - 1)
+            throw new Error("Git returned a malformed unmerged index row");
+        paths.add(row.slice(tab + 1));
+    }
+    return [...paths].sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
+}
+export function createProductionMergerGitState(repositoryRoot = process.cwd()) {
+    return {
+        async activeMerge() {
+            const targetObjectId = line(await git(repositoryRoot, ["rev-parse", "--verify", "HEAD"]), "Git HEAD");
+            let mergeHeadRaw;
+            try {
+                mergeHeadRaw = await git(repositoryRoot, ["rev-parse", "--verify", "MERGE_HEAD"]);
+            }
+            catch {
+                throw new Error("Assigned repository does not have one ordinary in-progress merge");
+            }
+            const mergeHeads = exactUtf8(mergeHeadRaw, "Git MERGE_HEAD").trim().split(/\r?\n/).filter(Boolean);
+            if (mergeHeads.length !== 1 || !isFullGitObjectId(targetObjectId) || !isFullGitObjectId(mergeHeads[0]) || targetObjectId.length !== mergeHeads[0].length)
+                throw new Error("Assigned repository does not have one ordinary in-progress merge");
+            let automaticMergeTreeRaw;
+            try {
+                automaticMergeTreeRaw = await git(repositoryRoot, ["rev-parse", "--verify", "AUTO_MERGE^{tree}"]);
+            }
+            catch {
+                throw new Error("Git automatic merge tree identity is unavailable or invalid");
+            }
+            const automaticMergeTreeId = line(automaticMergeTreeRaw, "Git automatic merge tree");
+            if (!isFullGitObjectId(automaticMergeTreeId) || automaticMergeTreeId.length !== targetObjectId.length)
+                throw new Error("Git automatic merge tree identity is unavailable or invalid");
+            return { targetObjectId, sourceObjectId: mergeHeads[0], unmergedPaths: await unmerged(repositoryRoot), automaticMergeTreeId };
+        },
+        async completedMerge(mergeCommitId, automaticMergeTreeId) {
+            if (!isFullGitObjectId(mergeCommitId) || !isFullGitObjectId(automaticMergeTreeId) || mergeCommitId.length !== automaticMergeTreeId.length)
+                throw new Error("Merger completion object ID is invalid");
+            const identity = exactUtf8(await git(repositoryRoot, ["show", "-s", "--format=%H%x00%P", mergeCommitId]), "Git merge commit").trimEnd().split("\0");
+            if (identity.length !== 2 || identity[0] !== mergeCommitId)
+                throw new Error("Git merge completion identity drifted");
+            const parentObjectIds = identity[1].split(" ").filter(Boolean);
+            const currentHead = line(await git(repositoryRoot, ["rev-parse", "--verify", "HEAD"]), "Git HEAD");
+            const status = await git(repositoryRoot, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+            const frozenTree = line(await git(repositoryRoot, ["rev-parse", "--verify", `${automaticMergeTreeId}^{tree}`]), "Git frozen automatic merge tree");
+            if (frozenTree !== automaticMergeTreeId)
+                throw new Error("Git frozen automatic merge tree identity drifted");
+            const mergeTree = line(await git(repositoryRoot, ["rev-parse", "--verify", `${mergeCommitId}^{tree}`]), "Git completed merge tree");
+            const resolutionChangedPaths = nulPaths(await git(repositoryRoot, ["diff-tree", "--no-commit-id", "--name-only", "-r", "-z", "--no-renames", automaticMergeTreeId, mergeTree]), "Git resolution path delta");
+            return { mergeCommitId: currentHead, parentObjectIds, unmergedPaths: await unmerged(repositoryRoot), worktreeClean: status.byteLength === 0 && currentHead === mergeCommitId, resolutionChangedPaths };
+        },
+    };
+}

package/dist/navigator-attendance.js

@@ -13,7 +13,7 @@ import {
   activationBookDirectory,
   resolveActivationLedgerHome
 } from "./activation-ledger-topology.js";
-import { createNativeNavigatorSessionFactory } from "./evidence-child-executor.js";
+import { createNativeNavigatorSessionFactory } from "./navigator-public-session.js";
 import {
   NAVIGATOR_DEFAULT_MODEL,
   NAVIGATOR_PREPARE_TOOL_NAME,
@@ -340,11 +340,7 @@ function createNavigatorAttendance(options) {
     routePlaybookSettlement = routePlaybookPromise.then(() => void 0);
     const modelPromise = (async () => {
       try {
-        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;
@@ -489,6 +485,11 @@ ${helpContext}
             return;
           }
           if (promptFailure !== void 0) throw promptFailure;
+          const sessionNoReceipt = activeSession.noReceipt?.();
+          if (sessionNoReceipt !== void 0) {
+            delivery.recordNestedNoReceipt(sessionNoReceipt);
+            return;
+          }
           if (deliveryRequest && output === void 0) delivery.recordDeliveryRequest();
         };
         await promptAllowingRejectedPrepare(request, false);
@@ -578,6 +579,7 @@ ${helpContext}
     }
   };
   async function settleOnce(settlement) {
+    if (disposed) return;
     const invocationId = activeInvocationId ?? invocationPrincipal;
     let report;
     if (settlement.kind === "human_decision" || settlement.kind === "role_infrastructure_failure") {
@@ -626,8 +628,10 @@ ${helpContext}
         session?.appendEntry(SETTLEMENT_ENTRY, { invocationId, subjectKey, role: settlement.role, phase: settlement.phase, kind: settlement.kind, ...settlement.status === void 0 ? {} : { status: settlement.status } });
         let selected = selectNavigatorCandidate(prepared, settlement);
         if (selected?.candidate.next !== void 0 && !selected.matchedToSettlement) {
+          if (disposed) return;
           prepareBoundSettlement = settlement;
           prepared = await prepare();
+          if (disposed) return;
           selected = selectNavigatorCandidate(prepared, settlement);
         }
         const selectedCandidate = selected?.candidate;
@@ -676,8 +680,12 @@ ${helpContext}
       ...report.routePlaybookReadFailure === void 0 ? {} : { routePlaybookReadFailure: report.routePlaybookReadFailure },
       ...report.arrivalMessage === void 0 ? {} : { arrivalMessage: report.arrivalMessage }
     };
-    if (!disposed) {
+    if (disposed) return;
+    try {
       await options.onEvent(event, report);
+    } catch (error) {
+      if (disposed) return;
+      throw error;
     }
     preparation = void 0;
     sessionReady = void 0;

package/dist/navigator-public-session.js

@@ -0,0 +1,170 @@
+import { sitianReport } from "./sitian-facade.js";
+import {
+  NavigatorUnavailableError,
+  navigatorProviderFailureFromDiagnostics,
+  navigatorProviderFailureFromError,
+  navigatorProviderFailureFromStatus,
+  navigatorUnavailableError,
+  parseNavigatorModelSetting,
+  resolveNavigatorSeatSelection
+} from "./navigator-session-contracts.js";
+function providerFailureFromPublicTerminal(outcome) {
+  const facts = outcome.decisiveFacts;
+  const secondary = typeof facts.secondaryEvidence === "object" && facts.secondaryEvidence !== null ? facts.secondaryEvidence : void 0;
+  const httpStatus = typeof secondary?.httpStatus === "number" ? secondary.httpStatus : typeof facts.httpStatus === "number" ? facts.httpStatus : typeof facts.errorCode === "number" ? facts.errorCode : void 0;
+  const fromStatus = navigatorProviderFailureFromStatus(httpStatus);
+  if (fromStatus !== void 0) return fromStatus;
+  const diagnostics = secondary?.diagnostics ?? facts.diagnostics;
+  const fromDiagnostics = navigatorProviderFailureFromDiagnostics(diagnostics);
+  if (fromDiagnostics !== void 0) return fromDiagnostics;
+  const fromCode = navigatorProviderFailureFromError({
+    code: secondary?.code ?? facts.errorCode
+  });
+  if (fromCode !== void 0) return fromCode;
+  if (outcome.cause === "provider") return { source: "transport", cause: "transport" };
+  return { source: "session", cause: "session" };
+}
+function createNativeNavigatorSessionFactory() {
+  return async ({ context, subject, tool }) => {
+    const resolved = await resolveNavigatorSeatSelection(context);
+    let thinkingLevel = resolved.thinkingLevel;
+    const { createRecordSession } = await import("./archivist-record-entry.js");
+    const sessionManager = createRecordSession({
+      cwd: context.cwd,
+      kind: "navigator",
+      subject,
+      parent: context.sessionManager
+    });
+    let providerFailure;
+    let noReceipt;
+    let disposed = false;
+    let inFlightPrompt;
+    const resolveHome = async () => {
+      const parentFile = context.sessionManager?.getSessionFile?.();
+      if (typeof parentFile === "string" && parentFile.trim() !== "") {
+        try {
+          const { tryHomeFromAkRolesPath, homeFromRunDirectory } = await import("./activation-ledger-topology.js");
+          const fromParent = tryHomeFromAkRolesPath(parentFile);
+          if (fromParent !== void 0 && fromParent.length > 0) return fromParent;
+          const runDir = parentFile.replace(/\/session\/session\.jsonl$/, "");
+          if (runDir !== parentFile) {
+            try {
+              return homeFromRunDirectory(runDir);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      const envHome = process.env.HOME;
+      return typeof envHome === "string" && envHome.trim() !== "" ? envHome : void 0;
+    };
+    return {
+      prompt: async (text) => {
+        if (disposed) {
+          throw navigatorUnavailableError("session", new Error("Navigator attendance was disposed"));
+        }
+        providerFailure = void 0;
+        noReceipt = void 0;
+        const run = (async () => {
+          try {
+            const { summonPublicRole } = await import("./public-role-summons.js");
+            const home = await resolveHome();
+            const summoned = await summonPublicRole({
+              role: "navigator",
+              argv: [text],
+              cwd: context.cwd,
+              ...home === void 0 ? {} : { home }
+            });
+            const outcome = summoned.terminal?.roleOutcome;
+            if (outcome === void 0) {
+              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") {
+              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;
+            }
+            await tool.execute(
+              "navigator-public-prepare",
+              { candidates },
+              void 0,
+              void 0,
+              context
+            );
+          } 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 = void 0;
+        }
+      },
+      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 {
+        }
+      },
+      entries: () => sessionManager.getEntries(),
+      setModel: async (next, nextThinking) => {
+        let nextParsed;
+        try {
+          nextParsed = parseNavigatorModelSetting(next);
+        } catch (error) {
+          throw navigatorUnavailableError("model", error);
+        }
+        thinkingLevel = nextThinking ?? nextParsed.thinkingLevel;
+      },
+      getThinkingLevel: () => thinkingLevel,
+      recordPointer: () => sessionManager.getSessionDir(),
+      dispose: async () => {
+        disposed = true;
+        const pending = inFlightPrompt;
+        if (pending !== void 0) await pending.catch(() => void 0);
+      }
+    };
+  };
+}
+export {
+  createNativeNavigatorSessionFactory
+};

package/dist/navigator-session-contracts.js

@@ -3,11 +3,6 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { auditorRunDirectory } from "./auditor-dossier-tool.js";
-import {
-  InstitutionalResolutionError,
-  readInstitutionalSeatSelection
-} from "./institutional-resolution.js";
 const NAVIGATOR_PREPARE_TOOL_NAME = "ak_navigator_prepare";
 const NAVIGATOR_DEFAULT_MODEL = "openai-codex/gpt-5.6-luna:max";
 const NAVIGATOR_UNAVAILABLE_KEYS = /* @__PURE__ */ new Set([
@@ -159,50 +154,51 @@ function parseNavigatorModelSetting(value) {
   const suffix = colon < 0 ? void 0 : 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");
-  return suffix === void 0 ? { provider, model } : { provider, model, thinkingLevel: suffix };
+  if (suffix !== void 0 && suffix.trim() === "") {
+    throw new Error("Navigator model setting thinking suffix must be non-blank");
+  }
+  return {
+    provider,
+    model,
+    ...suffix === void 0 ? {} : { thinkingLevel: suffix }
+  };
 }
-async function resolveNavigatorSeatSelection(context, modelSettingPath, defaultModelSettingPath) {
-  const runDirectory = auditorRunDirectory(context);
-  if (runDirectory !== void 0) {
-    try {
-      const selection = await readInstitutionalSeatSelection(runDirectory, "navigator");
+async function resolveNavigatorSeatSelection(context) {
+  try {
+    const { loadPublicCliConfig } = await import("./public-cli/config.js");
+    const { seatModelOnly } = await import("./public-cli/registry.js");
+    const { packageMachineHome } = await import("./activation-ledger-topology.js");
+    const homeCandidate = context.home;
+    const envHome = process.env.HOME;
+    const home = typeof homeCandidate === "string" ? homeCandidate : typeof envHome === "string" && envHome.trim() !== "" ? envHome : packageMachineHome();
+    const config = await loadPublicCliConfig(home);
+    const modelOnly = seatModelOnly(config.seats.navigator);
+    if (modelOnly === void 0) {
+      const parsed = parseNavigatorModelSetting(NAVIGATOR_DEFAULT_MODEL);
       return {
         selection: {
-          provider: selection.provider,
-          model: selection.model,
-          ...selection.thinking === void 0 ? {} : { thinking: selection.thinking }
+          provider: parsed.provider,
+          model: parsed.model,
+          ...parsed.thinkingLevel === void 0 ? {} : { thinking: parsed.thinkingLevel }
         },
-        configuredLabel: selection.thinking === void 0 ? `${selection.provider}/${selection.model}` : `${selection.provider}/${selection.model}:${selection.thinking}`,
-        ...selection.thinking === void 0 ? {} : { thinkingLevel: selection.thinking }
+        configuredLabel: NAVIGATOR_DEFAULT_MODEL,
+        ...parsed.thinkingLevel === void 0 ? {} : { thinkingLevel: parsed.thinkingLevel }
       };
-    } catch (error) {
-      if (error instanceof InstitutionalResolutionError && (error.reason === "missing-page" || error.reason === "missing-seat")) {
-      } else {
-        throw error instanceof NavigatorUnavailableError ? error : navigatorUnavailableError("model", error);
-      }
     }
-  }
-  let configured;
-  try {
-    configured = await readNavigatorModelSetting(modelSettingPath ?? defaultModelSettingPath);
+    const thinkingRaw = modelOnly.thinking;
+    const configuredLabel = thinkingRaw === void 0 ? `${modelOnly.provider}/${modelOnly.model}` : `${modelOnly.provider}/${modelOnly.model}:${thinkingRaw}`;
+    return {
+      selection: {
+        provider: modelOnly.provider,
+        model: modelOnly.model,
+        ...thinkingRaw === void 0 ? {} : { thinking: thinkingRaw }
+      },
+      configuredLabel,
+      ...thinkingRaw === void 0 ? {} : { thinkingLevel: thinkingRaw }
+    };
   } catch (error) {
     throw navigatorUnavailableError("model", error);
   }
-  let parsed;
-  try {
-    parsed = parseNavigatorModelSetting(configured);
-  } catch (error) {
-    throw navigatorUnavailableError("model", error);
-  }
-  return {
-    selection: {
-      provider: parsed.provider,
-      model: parsed.model,
-      ...parsed.thinkingLevel === void 0 ? {} : { thinking: parsed.thinkingLevel }
-    },
-    configuredLabel: configured,
-    ...parsed.thinkingLevel === void 0 ? {} : { thinkingLevel: parsed.thinkingLevel }
-  };
 }
 export {
   NAVIGATOR_DEFAULT_MODEL,

package/dist/notary-source-run.js

@@ -0,0 +1,122 @@
+/**
+ * Resolve and validate the public Notary source-run locator.
+ * Only machine-ledger retained runs are authoritative: no project-tree projection,
+ * no attachment substitute. Caller supplies a run/case pointer; Notary self-fetches.
+ */
+import { dirname, isAbsolute, join, resolve, basename } from "node:path";
+import { lstat, realpath } from "node:fs/promises";
+import { resolveBookKeyFromGit } from "./activation-ledger-git.js";
+import { activationBookDirectory, physicalPathIdentity, resolveActivationLedgerHome, } from "./activation-ledger-topology.js";
+import { readRoleRunIdentity } from "./public-cli/run-lifecycle.js";
+// 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 = /^([A-Za-z0-9][A-Za-z0-9._-]*)@([A-Za-z][A-Za-z0-9_-]*)$/;
+export class NotarySourceRunError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "NotarySourceRunError";
+    }
+}
+function parseRunDirectoryName(name) {
+    const match = RUN_DIR_NAME.exec(name);
+    if (match === null)
+        return undefined;
+    return { runId: match[1], role: match[2] };
+}
+async function requireRunDirectory(candidate, display) {
+    let real;
+    try {
+        real = await realpath(candidate);
+    }
+    catch (error) {
+        throw new NotarySourceRunError(`notary --source-run is not a readable run directory: ${display}`, { cause: error });
+    }
+    let stat;
+    try {
+        stat = await lstat(real);
+    }
+    catch (error) {
+        throw new NotarySourceRunError(`notary --source-run is not a readable run directory: ${display}`, { cause: error });
+    }
+    if (!stat.isDirectory()) {
+        throw new NotarySourceRunError(`notary --source-run must be a run directory: ${display}`);
+    }
+    const identity = parseRunDirectoryName(basename(real));
+    if (identity === undefined) {
+        throw new NotarySourceRunError(`notary --source-run must be named <runId>@<role>: ${basename(real)}`);
+    }
+    return real;
+}
+/**
+ * Resolve `--source-run` to a machine-ledger retained run directory and typed identity.
+ * Accepts:
+ * - bare `<runId>@<role>` under the project's book runs home
+ * - absolute/relative path that realpath's to that same book runs slot
+ *
+ * Rejects project-tree projections and any path outside the project's ledger book runs.
+ * Retained `run-state.json` must match basename identity and book binding.
+ */
+export async function resolveNotarySourceRunLocator(options) {
+    const raw = options.sourceRun.trim();
+    if (raw === "") {
+        throw new NotarySourceRunError("notary --source-run requires a run locator");
+    }
+    const ledgerHome = resolveActivationLedgerHome(options.home);
+    const bookKey = resolveBookKeyFromGit(options.projectRoot);
+    const bookRunsRoot = join(activationBookDirectory(ledgerHome, bookKey), "runs");
+    let candidate;
+    const bare = parseRunDirectoryName(raw);
+    if (bare !== undefined && !raw.includes("/") && !raw.includes("\\")) {
+        candidate = join(bookRunsRoot, `${bare.runId}@${bare.role}`);
+    }
+    else {
+        candidate = isAbsolute(raw) ? raw : resolve(options.projectRoot, raw);
+    }
+    const real = await requireRunDirectory(candidate, raw);
+    const identity = parseRunDirectoryName(basename(real));
+    const runsRootIdentity = physicalPathIdentity(bookRunsRoot);
+    const parentIdentity = physicalPathIdentity(dirname(real));
+    if (parentIdentity !== runsRootIdentity) {
+        throw new NotarySourceRunError("notary --source-run must resolve to a retained run under the project machine-ledger book");
+    }
+    // Authoritative retained record only — legal role/state via shared reader (DRY #14).
+    // Identity envelope only: principal payload is not interpreted here.
+    const runState = await readRoleRunIdentity(real);
+    if (runState === undefined) {
+        throw new NotarySourceRunError("notary --source-run lacks retained run-state identity");
+    }
+    if (runState.runId !== identity.runId || runState.role !== identity.role) {
+        throw new NotarySourceRunError("notary --source-run retained identity does not match directory name");
+    }
+    if (runState.bookKey !== bookKey) {
+        throw new NotarySourceRunError("notary --source-run retained book binding does not match project case");
+    }
+    if (physicalPathIdentity(runState.runDirectory) !== physicalPathIdentity(real)) {
+        throw new NotarySourceRunError("notary --source-run retained runDirectory does not match locator path");
+    }
+    return {
+        runDirectory: real,
+        runId: identity.runId,
+        role: identity.role,
+    };
+}
+/** Internal activation loader: path is the admitted absolute source run directory. */
+export async function loadNotarySourceRunLocator(path) {
+    const real = await requireRunDirectory(path, path);
+    const identity = parseRunDirectoryName(basename(real));
+    const runState = await readRoleRunIdentity(real);
+    if (runState === undefined) {
+        throw new NotarySourceRunError("notary source-run lacks retained run-state identity");
+    }
+    if (runState.runId !== identity.runId || runState.role !== identity.role) {
+        throw new NotarySourceRunError("notary source-run retained identity does not match directory name");
+    }
+    if (physicalPathIdentity(runState.runDirectory) !== physicalPathIdentity(real)) {
+        throw new NotarySourceRunError("notary source-run retained runDirectory does not match locator path");
+    }
+    return {
+        runDirectory: real,
+        runId: identity.runId,
+        role: identity.role,
+    };
+}

package/dist/package-contracts/auditor-output.js

@@ -0,0 +1,66 @@
+/**
+ * Public Auditor (审刑院) terminating receipt contracts (#675).
+ * Lawful explicit releases: pass | revise | escalate.
+ */
+import { Type } from "typebox";
+import { openToolObject } from "../open-tool-schema.js";
+import { withInfrastructureFailureDeclaration } from "./terminating-infrastructure.js";
+export const AUDITOR_OUTPUT_TOOL_NAME = "ak_auditor_output";
+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 时的决策闸",
+    })),
+})));
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function projectLawfulAuditorOutput(value) {
+    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) {
+    const projected = projectLawfulAuditorOutput(value);
+    if (projected === undefined) {
+        throw new Error("Auditor output has no recognized execution discriminator");
+    }
+    return projected;
+}
+export function auditorDecisiveFacts(output) {
+    const facts = { 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/dist/package-contracts/evidence-child-output.js

@@ -0,0 +1,34 @@
+/**
+ * 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.js";
+import { withInfrastructureFailureDeclaration } from "./terminating-infrastructure.js";
+export const EVIDENCE_CHILD_OUTPUT_TOOL_NAME = "ak_evidence_child_output";
+export const EVIDENCE_CHILD_ACCEPTED_TEXT = "取证回执已接受";
+export const evidenceChildOutputSchema = withInfrastructureFailureDeclaration(openToolObject(Type.Object({
+    report: Type.Unknown({
+        description: "取证报告正文 — 形状指引，非 schema 闸",
+    }),
+})));
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function projectLawfulEvidenceChildOutput(value) {
+    // 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) {
+    const projected = projectLawfulEvidenceChildOutput(value);
+    if (projected === undefined) {
+        throw new Error("Evidence-child output is not an object");
+    }
+    return projected;
+}
+export function evidenceChildDecisiveFacts(output) {
+    return { report: output.report };
+}

package/dist/package-contracts/judge-output.js

@@ -1,6 +1,7 @@
 const JUDGE_OUTPUT_TOOL_NAME = "ak_judge_output";
 const JUDGE_ACCEPTED_TEXT = "\u5927\u7406\u5BFA\u56DE\u6267\u5DF2\u63A5\u53D7";
 const JUDGE_ACCEPTED_AUDIT_NO_RECEIPT_TEXT = "\u5927\u7406\u5BFA\u56DE\u6267\u5DF2\u63A5\u53D7\uFF1B\u5BA1\u8BA1\u65E0\u56DE\u6267";
+const JUDGE_ACCEPTED_AUDIT_UNREADABLE_TEXT = "\u5927\u7406\u5BFA\u56DE\u6267\u5DF2\u63A5\u53D7\uFF1B\u5BA1\u8BA1\u5F62\u72B6\u4E0D\u53EF\u8BFB";
 function validateAcceptedJudgeDetails(verdict) {
   if (verdict === null || typeof verdict !== "object" || Array.isArray(verdict)) throw new Error("Judge verdict has no execution discriminator");
   let judgeStatus;
@@ -19,6 +20,7 @@ function validateAcceptedJudgeDetails(verdict) {
 }
 export {
   JUDGE_ACCEPTED_AUDIT_NO_RECEIPT_TEXT,
+  JUDGE_ACCEPTED_AUDIT_UNREADABLE_TEXT,
   JUDGE_ACCEPTED_TEXT,
   JUDGE_OUTPUT_TOOL_NAME,
   validateAcceptedJudgeDetails