@akagilnc/pi-workflow-roles 0.1.2296 → 0.1.2310

package/extensions/role-runtime.ts

@@ -3,6 +3,7 @@ import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 
 import { loadDoctorCase } from "../src/doctor-evidence.ts";
+import { loadNotarySourceRunLocator } from "../src/notary-source-run.ts";
 import { loadAdmittedJudgeRequest } from "../src/public-cli/invocation.ts";
 
 import {
@@ -145,7 +146,9 @@ export async function loadNavigatorWorkContext(
   options: { context: ExtensionContext; role: string },
 ): Promise<{ subjectKey: string; subject: string; authority: string; subjectProvenance: NavigatorSubjectProvenance }> {
   const reference = navigatorInputReference(pi as ExtensionAPI, options.role);
-  const input = reference === undefined || options.role === "doctor" ? undefined : await readFile(reference, "utf8");
+  const input = reference === undefined || options.role === "doctor" || options.role === "notary"
+    ? undefined
+    : await readFile(reference, "utf8");
   const subjectRoot = subjectPath(reference ?? options.context.sessionManager.getSessionDir(), options.context.cwd);
   let subjectKey = reference === undefined
     ? subjectRoot
@@ -157,6 +160,11 @@ export async function loadNavigatorWorkContext(
     subject = JSON.stringify({ identity: patient.identity, cost: patient.cost });
     subjectProvenance = "role_input";
   }
+  if (options.role === "notary" && reference !== undefined) {
+    const locator = await loadNotarySourceRunLocator(reference);
+    subject = JSON.stringify({ sourceRun: locator });
+    subjectProvenance = "role_input";
+  }
   // Public ak-role run: admitted request is the typed Navigator work-context source.
   // Classification failure here stays source=context (distinct from model/session/transport).
   const publicRunDir = process.env.AK_ROLE_RUN_DIR;
@@ -257,6 +265,8 @@ export default function roleRuntime(pi: ExtensionAPI): void {
     loadDoctorSoul: () => loadMainRoleSessionMaterials("doctor"),
     loadDoctorCase,
     auditDoctorCompliance: createPiDoctorAuditor(),
+    loadNotarySoul: () => loadMainRoleSessionMaterials("notary"),
+    loadNotarySourceRun: loadNotarySourceRunLocator,
     loadNavigatorWorkContext: (options) => loadNavigatorWorkContext(pi, options),
     createNavigatorAttendance: (options) => {
       return createNavigatorAttendance({

package/package.json

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

package/souls/judge-output-guide.md

@@ -3,5 +3,8 @@
 拟判正文应自带：
 
 - 凡称陛下拍定：附可追溯真源。
-- 承重主张（引用的法源、声称的代码事实）：附原文并列引用，开卷可核。
+- 承重主张（引用的法源、声称的代码事实）：给指针（路径/行号/runId），或从本轮已打开的源头逐字节复制引文——禁止凭记忆改写、缩写或转述；开卷核对相符即成立。
+- 每句「已核/已对齐」：对应本轮工具轨迹中可见的打开动作；写不出对应动作的句子删去。
+- 因误引/未核被打回后重交：被点名的每个事实重新打开源头再引，不许只改措辞重交。
+- 票面或 OWNER 点名的交付项：逐项列清单处置后再交；漏一项即不完整。
 - 对票面的裁决：先答它解决什么真问题；讲不清的，打回签发方，不得结清。

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

@@ -14,8 +14,10 @@
  * 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. True non-gate volumes
- * (soul-audit noise, etc.) stay omitted from pairing.
+ * 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.
  */
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
@@ -202,6 +204,9 @@ async function classifyAuditorVolume(
   const findingsCount = Array.isArray(findings) ? findings.length : 0;
 
   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;
     if (status !== "dispatch") {
       throw new Error(
         `accepted dispatch receipt has non-dispatch status ${JSON.stringify(status)} in ${filePath}`,

package/src/notary-contracts.ts

@@ -0,0 +1,134 @@
+/**
+ * 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.
+ */
+import { Type } from "typebox";
+
+import {
+  readActivationEngineLaborFallbackField,
+  seatFallbackBaseStatus,
+  seatFallbackStatusHasLawfulEvidence,
+  withEngineLaborFallbackField,
+  type WithEngineLaborFallback,
+} from "./engine-labor-fallback.ts";
+import { openToolObject } from "./open-tool-schema.ts";
+
+export const NOTARY_OUTPUT_TOOL_NAME = "ak_notary_output";
+export const NOTARY_ACCEPTED_TEXT = "Notary output accepted";
+export const NOTARY_SOURCE_RUN_FLAG = {
+  name: "ak-notary-source-run",
+  definition: {
+    description: "Absolute source run directory bound for Notary self-fetch",
+    type: "string" as const,
+  },
+} as const;
+
+/** Package-owned kickoff only — callers supply zero prompt bytes (ADR 0067 / #448). */
+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.",
+    }),
+    findings: Type.Unknown({
+      description: "string[] findings retained with pass or bounce.",
+    }),
+    reason: Type.Unknown({
+      description: "Why the notary decision is incomplete.",
+    }),
+  }),
+);
+
+export type NotarySourceRunLocator = {
+  readonly runDirectory: string;
+  readonly runId: string;
+  readonly role: string;
+};
+
+type NotaryOutputClean =
+  | { readonly status: "pass"; readonly findings: readonly string[] }
+  | {
+      readonly status: "bounce";
+      readonly disposition: "rewrite";
+      readonly findings: readonly string[];
+    }
+  | { readonly status: "incomplete"; readonly reason: string };
+
+/** Clean submission or seat-fallback tainted accepted receipt (ADR 0071). */
+export type NotaryOutput =
+  | NotaryOutputClean
+  | WithEngineLaborFallback<NotaryOutputClean>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asStringArray(value: unknown): readonly string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is string => typeof item === "string");
+}
+
+/**
+ * Project one explicit Notary release. Throws when there is no lawful explicit
+ * pass / bounce / incomplete(reason) — callers map that to residual incomplete.
+ */
+export function validateNotaryOutput(value: unknown): NotaryOutput {
+  if (!isRecord(value)) {
+    throw new Error("Notary output has no recognized execution discriminator");
+  }
+  const statusRaw = typeof value.status === "string" ? value.status : undefined;
+  if (statusRaw === undefined || !seatFallbackStatusHasLawfulEvidence(statusRaw, 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) as NotaryOutput;
+  }
+  if (status === "bounce") {
+    const clone = structuredClone(value) as Record<string, unknown>;
+    if (clone.disposition === undefined) clone.disposition = "rewrite";
+    if (!Array.isArray(clone.findings)) clone.findings = asStringArray(clone.findings);
+    return clone as NotaryOutput;
+  }
+  if (status === "pass") {
+    const clone = structuredClone(value) as Record<string, unknown>;
+    if (!Array.isArray(clone.findings)) clone.findings = asStringArray(clone.findings);
+    return clone as NotaryOutput;
+  }
+  throw new Error("Notary output has no recognized execution discriminator");
+}
+
+/** Shape check for recorded accepted details (may include engineLaborFallback). */
+export function validateRecordedNotaryOutput(value: unknown): NotaryOutput {
+  return validateNotaryOutput(value);
+}
+
+export function withNotaryAcceptedDetails(output: NotaryOutput): NotaryOutput {
+  return withEngineLaborFallbackField(
+    output,
+    readActivationEngineLaborFallbackField(),
+  ) as NotaryOutput;
+}
+
+export function notaryDecisiveFacts(output: NotaryOutput): Record<string, unknown> {
+  const status = seatFallbackBaseStatus(String(output.status));
+  const facts: Record<string, unknown> = { status, officer: "notary" };
+  if (status === "pass" || status === "bounce") {
+    const findings = (output as { findings?: unknown }).findings;
+    facts.findingsCount = Array.isArray(findings) ? findings.length : 0;
+  }
+  if (status === "bounce") {
+    facts.disposition = "rewrite";
+  }
+  if (status === "incomplete") {
+    facts.reason = (output as { reason: string }).reason;
+  }
+  return facts;
+}

package/src/notary-role.ts

@@ -0,0 +1,148 @@
+/**
+ * Public Notary role runtime — direct officer seat (not through Gatekeeper province).
+ * Caller supplies only a source-run locator; Notary self-fetches authoritative materials.
+ */
+import type {
+  AgentToolResult,
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+import {
+  NOTARY_ACCEPTED_TEXT,
+  NOTARY_OUTPUT_TOOL_NAME,
+  NOTARY_SOURCE_RUN_FLAG,
+  notaryOutputSchema,
+  validateNotaryOutput,
+  withNotaryAcceptedDetails,
+  type NotarySourceRunLocator,
+} from "./notary-contracts.ts";
+
+export {
+  NOTARY_ACCEPTED_TEXT,
+  NOTARY_OUTPUT_TOOL_NAME,
+  NOTARY_SOURCE_RUN_FLAG,
+};
+
+export type NotaryRoleDependencies = {
+  loadSoul(): Promise<string>;
+  loadSourceRunLocator(path: string): Promise<NotarySourceRunLocator>;
+};
+
+export type NotaryRoleHostActions = {
+  failInfrastructure(
+    error: unknown,
+    ctx: ExtensionContext,
+    toolCallId?: string,
+  ): never;
+};
+
+function requireSingletonSubmissionCall(
+  toolCallId: string,
+  ctx: ExtensionContext,
+): void {
+  const leaf = ctx.sessionManager.getLeafEntry();
+  if (leaf?.type !== "message" || leaf.message.role !== "assistant") {
+    throw new Error("Notary output must be the sole final tool call");
+  }
+  const calls = leaf.message.content.filter((part) => part.type === "toolCall");
+  if (
+    calls.length !== 1 ||
+    calls[0]?.id !== toolCallId ||
+    calls[0]?.name !== NOTARY_OUTPUT_TOOL_NAME
+  ) {
+    throw new Error("Notary output must be the sole final tool call");
+  }
+}
+
+export function createNotaryRoleRuntime(
+  pi: ExtensionAPI,
+  dependencies: NotaryRoleDependencies,
+  host: NotaryRoleHostActions,
+) {
+  let activation:
+    | { soul: string; sourceRun: NotarySourceRunLocator }
+    | undefined;
+  let registered = false;
+  pi.registerFlag(
+    NOTARY_SOURCE_RUN_FLAG.name,
+    NOTARY_SOURCE_RUN_FLAG.definition,
+  );
+
+  return {
+    async activate() {
+      const path = pi.getFlag(NOTARY_SOURCE_RUN_FLAG.name);
+      if (typeof path !== "string" || path.trim() === "") {
+        throw new Error("Notary requires --ak-notary-source-run");
+      }
+      const soul = (await dependencies.loadSoul()).trim();
+      if (soul.length === 0) throw new Error("Notary soul is empty");
+      const sourceRun = await dependencies.loadSourceRunLocator(path);
+      activation = { soul, sourceRun };
+
+      if (!registered) {
+        registered = true;
+        pi.registerTool({
+          name: NOTARY_OUTPUT_TOOL_NAME,
+          label: "Notary Output",
+          description:
+            "Submit one typed pass, bounce, or incomplete decision on quote fidelity and ticket alignment.",
+          promptSnippet: "Submit the Notary decision",
+          promptGuidelines: [
+            `Use ${NOTARY_OUTPUT_TOOL_NAME} as the sole final action.`,
+            "Fetch ticket, git, and dossier evidence yourself from the bound source-run locator.",
+          ],
+          parameters: notaryOutputSchema,
+          async execute(
+            toolCallId,
+            parameters,
+            _signal,
+            _onUpdate,
+            ctx,
+          ): Promise<AgentToolResult<unknown>> {
+            if (activation === undefined) {
+              throw new Error("Notary is not activated");
+            }
+            let output;
+            try {
+              requireSingletonSubmissionCall(toolCallId, ctx);
+              output = validateNotaryOutput(parameters);
+            } catch (error) {
+              // Non-explicit release stays a rejected terminating call so public
+              // settlement can project residual incomplete (layer ②).
+              throw error instanceof Error
+                ? error
+                : new Error(String(error));
+            }
+            const acceptedDetails = withNotaryAcceptedDetails(output);
+            return {
+              content: [{ type: "text" as const, text: NOTARY_ACCEPTED_TEXT }],
+              details: acceptedDetails,
+              terminate: true as const,
+            };
+          },
+        });
+        pi.on("before_agent_start", (event) => {
+          if (activation === undefined) {
+            throw new Error("Notary is not activated");
+          }
+          // Locator only — never preload ticket/diff/draft body (self-fetch contract).
+          const bound = {
+            sourceRun: activation.sourceRun,
+          };
+          return {
+            systemPrompt: `${event.systemPrompt}\n\n<notary_soul>\n${activation.soul}\n</notary_soul>\n\n<notary_source_run>\n${JSON.stringify(bound)}\n</notary_source_run>`,
+          };
+        });
+      }
+
+      // Evidence role: keep Pi default tools + notary output (ADR 0064 unrestricted).
+      const all = pi.getAllTools().map((tool) => tool.name);
+      if (all.filter((name) => name === NOTARY_OUTPUT_TOOL_NAME).length !== 1) {
+        throw new Error(
+          `Notary required tool collision or missing: ${NOTARY_OUTPUT_TOOL_NAME}`,
+        );
+      }
+    },
+  };
+}

package/src/notary-source-run.ts

@@ -0,0 +1,168 @@
+/**
+ * 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.ts";
+import {
+  activationBookDirectory,
+  physicalPathIdentity,
+  resolveActivationLedgerHome,
+} from "./activation-ledger-topology.ts";
+import type { NotarySourceRunLocator } from "./notary-contracts.ts";
+import { readRoleRunState } from "./public-cli/run-lifecycle.ts";
+
+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;
+
+export class NotarySourceRunError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "NotarySourceRunError";
+  }
+}
+
+function parseRunDirectoryName(name: string): { runId: string; role: string } | undefined {
+  const match = RUN_DIR_NAME.exec(name);
+  if (match === null) return undefined;
+  return { runId: match[1]!, role: match[2]! };
+}
+
+async function requireRunDirectory(candidate: string, display: string): Promise<string> {
+  let real: string;
+  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: {
+  readonly projectRoot: string;
+  readonly sourceRun: string;
+  readonly home?: string;
+}): Promise<NotarySourceRunLocator> {
+  const raw = options.sourceRun.trim();
+  if (raw === "") {
+    throw new NotarySourceRunError("notary --source-run requires a run locator");
+  }
+
+  const ledgerHome = resolveActivationLedgerHome(
+    options.home === undefined ? undefined : () => options.home!,
+  );
+  const bookKey = resolveBookKeyFromGit(options.projectRoot);
+  const bookRunsRoot = join(activationBookDirectory(ledgerHome, bookKey), "runs");
+
+  let candidate: string;
+  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).
+  const runState = await readRoleRunState(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: string,
+): Promise<NotarySourceRunLocator> {
+  const real = await requireRunDirectory(path, path);
+  const identity = parseRunDirectoryName(basename(real))!;
+  const runState = await readRoleRunState(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/src/package-contracts/terminating-tools.ts

@@ -31,6 +31,7 @@ import {
 } from "../engine-labor-fallback.ts";
 import { DOCTOR_OUTPUT_TOOL_NAME, validateDoctorSubmissionShape, validateRecordedDoctorOutput, type DoctorOutput, type DoctorSubmission } from "../doctor-contracts.ts";
 import { MERGER_ACCEPTED_TEXT, MERGER_OUTPUT_TOOL_NAME, validateMergerOutput, type MergerOutput } from "../merger-contracts.ts";
+import { NOTARY_ACCEPTED_TEXT, NOTARY_OUTPUT_TOOL_NAME, validateRecordedNotaryOutput, type NotaryOutput } from "../notary-contracts.ts";
 import {
   CODER_ACCEPTED_TEXT,
   CODER_OUTPUT_TOOL_NAME,
@@ -62,6 +63,7 @@ export {
   validateDoctorSubmissionShape,
   validateRecordedDoctorOutput,
   validateMergerOutput,
+  validateRecordedNotaryOutput,
 };
 export type {
   CollectorReceipt,
@@ -72,6 +74,7 @@ export type {
   DoctorOutput,
   DoctorSubmission,
   MergerOutput,
+  NotaryOutput,
 };
 
 export const TERMINATING_TOOL_NAMES = [
@@ -82,6 +85,7 @@ export const TERMINATING_TOOL_NAMES = [
   COLLECTOR_OUTPUT_TOOL,
   DOCTOR_OUTPUT_TOOL_NAME,
   MERGER_OUTPUT_TOOL_NAME,
+  NOTARY_OUTPUT_TOOL_NAME,
 ] as const;
 
 export type TerminatingToolName = (typeof TERMINATING_TOOL_NAMES)[number];
@@ -92,7 +96,8 @@ export type AcceptedDetails =
   | JudgeVerdict
   | CollectorReceipt
   | DoctorOutput
-  | MergerOutput;
+  | MergerOutput
+  | NotaryOutput;
 
 export function isTerminatingToolName(
   name: string,
@@ -116,6 +121,8 @@ export function acceptedTextFor(toolName: TerminatingToolName): string {
       return "Doctor output accepted";
     case MERGER_OUTPUT_TOOL_NAME:
       return MERGER_ACCEPTED_TEXT;
+    case NOTARY_OUTPUT_TOOL_NAME:
+      return NOTARY_ACCEPTED_TEXT;
   }
 }
 
@@ -161,6 +168,7 @@ export function validateAcceptedDetails(
     [COLLECTOR_OUTPUT_TOOL]: [],
     [DOCTOR_OUTPUT_TOOL_NAME]: ["completed", "refused"],
     [MERGER_OUTPUT_TOOL_NAME]: ["completed", "escalate"],
+    [NOTARY_OUTPUT_TOOL_NAME]: ["pass", "bounce", "incomplete"],
   };
   const collectorDiscriminator = toolName === COLLECTOR_OUTPUT_TOOL && Array.isArray(candidate?.groups);
   const baseDiscriminator = typeof discriminator === "string" ? seatFallbackBaseStatus(discriminator) : discriminator;
@@ -194,6 +202,8 @@ export function validateAcceptedDetails(
       return validateRecordedDoctorOutput(details);
     case MERGER_OUTPUT_TOOL_NAME:
       return validateMergerOutput(details);
+    case NOTARY_OUTPUT_TOOL_NAME:
+      return validateRecordedNotaryOutput(details);
     }
   } catch (error) {
     if (error instanceof Error && error.constructor === Error) throw new AcceptedDetailsContractError(error.message, { cause: error });
@@ -237,7 +247,8 @@ export function acceptedFacts(toolName: TerminatingToolName, details: AcceptedDe
     case CODER_OUTPUT_TOOL_NAME:
     case FIXER_OUTPUT_TOOL_NAME:
     case REVIEWER_OUTPUT_TOOL_NAME:
-    case DOCTOR_OUTPUT_TOOL_NAME: return { status: (details as { status: string }).status };
+    case DOCTOR_OUTPUT_TOOL_NAME:
+    case NOTARY_OUTPUT_TOOL_NAME: return { status: (details as { status: string }).status };
     case JUDGE_OUTPUT_TOOL_NAME: return { status: (details as { judgeStatus: string }).judgeStatus };
     case MERGER_OUTPUT_TOOL_NAME: {
       const output = details as unknown as Record<string, unknown>;

package/src/packaged-role-registry.ts

@@ -5,6 +5,7 @@ import { REVIEWER_OUTPUT_TOOL_NAME } from "./package-contracts/reviewer-output.t
 import { CODER_OUTPUT_TOOL_NAME, FIXER_OUTPUT_TOOL_NAME } from "./package-contracts/worker-output.ts";
 import { DOCTOR_OUTPUT_TOOL_NAME } from "./doctor-contracts.ts";
 import { MERGER_OUTPUT_TOOL_NAME } from "./merger-contracts.ts";
+import { NOTARY_OUTPUT_TOOL_NAME } from "./notary-contracts.ts";
 
 export const PACKAGED_ROLE_REGISTRY = [
   { role: "judge", phases: [null], outputTool: JUDGE_OUTPUT_TOOL_NAME, inputFlag: undefined, phaseFlag: undefined, activationStage: "load-and-install" },
@@ -14,6 +15,7 @@ export const PACKAGED_ROLE_REGISTRY = [
   { role: "collector", phases: [null], outputTool: COLLECTOR_OUTPUT_TOOL, inputFlag: "ak-collector-repo", phaseFlag: undefined, activationStage: "load-and-install" },
   { role: "doctor", phases: [null], outputTool: DOCTOR_OUTPUT_TOOL_NAME, inputFlag: "ak-doctor-case", phaseFlag: undefined, activationStage: "load-and-install" },
   { role: "merger", phases: [null], outputTool: MERGER_OUTPUT_TOOL_NAME, inputFlag: "ak-merger-input", phaseFlag: undefined, activationStage: "prepare-git-and-install" },
+  { role: "notary", phases: [null], outputTool: NOTARY_OUTPUT_TOOL_NAME, inputFlag: "ak-notary-source-run", phaseFlag: undefined, activationStage: "load-and-install" },
 ] as const;
 
 export type PackagedRole = (typeof PACKAGED_ROLE_REGISTRY)[number]["role"];