@akagilnc/pi-workflow-roles 0.1.3644 → 0.1.3652

package/dist/collector-role.js

@@ -0,0 +1,441 @@
+import { COLLECTOR_FIXED_KICKOFF, emptyCollectorManifest, loadCollectorManifest, parseCollectorPrNumber, parseCollectorRepository, } from "./collector-config.js";
+import { createSystemCollectorClock, } from "./collector-evidence.js";
+import { COLLECTOR_OBSERVE_TOOL, COLLECTOR_OUTPUT_TOOL, COLLECTOR_READ_TOOL, COLLECTOR_REQUEST_TOOL, COLLECTOR_WAIT_TOOL, projectEvidenceEntryView, } from "./collector-ledger.js";
+import { buildCollectorReceipt, } from "./collector-receipt.js";
+import { collectorObserveArgsSchema, collectorOutputArgsSchema, collectorReadArgsSchema, collectorRequestArgsSchema, collectorWaitArgsSchema, } from "./collector-tool-schemas.js";
+import { COLLECTOR_ACCEPTED_TEXT } from "./package-contracts/collector-output.js";
+import { CorrectableSubmissionError, isCorrectableExecuteError } from "./submission-correctable-error.js";
+import { CollectorUnknownEvidenceError } from "./collector-identity.js";
+export { CollectorUnknownEvidenceError } from "./collector-identity.js";
+/**
+ * #641 chain②: normal completion must never declare `infrastructureFailure`.
+ * When the runtime can machine-verify a lawful receipt assembly, a declaration
+ * is model misuse — bounce it as correctable guidance instead of host failure.
+ */
+export class CollectorNormalCompletionDeclarationError extends CorrectableSubmissionError {
+    constructor() {
+        super("runtime 已按机器状态核验本局为正常完工（回执可合法组装）：正常完工的交件不得填 infrastructureFailure，请省略该字段后重新提交。");
+        this.name = "CollectorNormalCompletionDeclarationError";
+    }
+}
+export { COLLECTOR_FIXED_KICKOFF, } from "./collector-config.js";
+export { COLLECTOR_OBSERVE_TOOL, COLLECTOR_OUTPUT_TOOL, COLLECTOR_READ_TOOL, COLLECTOR_REQUEST_TOOL, COLLECTOR_WAIT_TOOL, };
+export const COLLECTOR_REQUIRED_TOOLS = [
+    COLLECTOR_OBSERVE_TOOL,
+    COLLECTOR_READ_TOOL,
+    COLLECTOR_REQUEST_TOOL,
+    COLLECTOR_WAIT_TOOL,
+    COLLECTOR_OUTPUT_TOOL,
+];
+const observeSchema = collectorObserveArgsSchema;
+const readSchema = collectorReadArgsSchema;
+const requestSchema = collectorRequestArgsSchema;
+const waitSchema = collectorWaitArgsSchema;
+const outputSchema = collectorOutputArgsSchema;
+/** Sole-final at the output execution seam (same shape as other terminating roles). */
+function buildMethodContext(activation) {
+    return [
+        "<collector_method>",
+        `host: github.com`,
+        `repository: ${activation.repository.canonical}`,
+        `prNumber: ${activation.prNumber}`,
+        `requests: ${JSON.stringify(activation.manifest.requests.map((request) => ({ id: request.id })))}`,
+        "</collector_method>",
+    ].join("\n");
+}
+export function createCollectorRoleRuntime(pi, dependencies, hostActions) {
+    let activation;
+    let inputCount = 0;
+    let lifecycleRegistered = false;
+    let toolsRegistered = false;
+    let firstDispatchDone = false;
+    pi.registerFlag("ak-collector-repo", {
+        description: "GitHub owner/repo target for Collector (github.com only; conservative ASCII grammar). Collector forbids every Skill, including command-only Skills.",
+        type: "string",
+    });
+    pi.registerFlag("ak-collector-pr", {
+        description: "Positive safe-integer pull request number for Collector. Supported profile: --no-skills, --no-extensions with only the explicit Collector package extension, no prompt templates/context files, one print/JSON prompt",
+        type: "string",
+    });
+    pi.registerFlag("ak-collector-request-manifest", {
+        description: "Path to the Collector v1 request manifest JSON file. In Pi latest, late hostile sibling-extension Skill injection is unsupported and fail-closed when detected; drift prevention only, not a security boundary or provider-zero guarantee",
+        type: "string",
+    });
+    const ensureLifecycle = () => {
+        if (lifecycleRegistered)
+            return;
+        lifecycleRegistered = true;
+        pi.on("input", (event, ctx) => {
+            if (activation === undefined) {
+                // role not active
+                return { action: "continue" };
+            }
+            if (inputCount >= 1) {
+                activation.ledger.latchFatal("通进司已拒绝后续输入");
+                if (process.exitCode === undefined || process.exitCode === 0) {
+                    process.exitCode = 1;
+                }
+                console.error("Collector rejected later input");
+                return { action: "handled" };
+            }
+            inputCount += 1;
+            return {
+                action: "transform",
+                text: COLLECTOR_FIXED_KICKOFF,
+                images: [],
+            };
+        });
+        pi.on("before_agent_start", (event, ctx) => {
+            if (activation === undefined)
+                return;
+            // Detectable ambient instruction resources on the supported prompt surface.
+            const options = event.systemPromptOptions;
+            if (options.skills && options.skills.length > 0) {
+                hostActions.failInfrastructure(activation.ledger.latchFatal("通进司检测到系统提示中的环境 skills"), ctx);
+            }
+            if (options.contextFiles && options.contextFiles.length > 0) {
+                hostActions.failInfrastructure(activation.ledger.latchFatal("通进司检测到系统提示中的环境 context files"), ctx);
+            }
+            if (typeof options.appendSystemPrompt === "string" &&
+                options.appendSystemPrompt.trim().length > 0) {
+                hostActions.failInfrastructure(activation.ledger.latchFatal("通进司检测到 appendSystemPrompt 漂移"), ctx);
+            }
+            if (event.prompt !== COLLECTOR_FIXED_KICKOFF) {
+                hostActions.failInfrastructure(activation.ledger.latchFatal("通进司首条提示不是固定开场令"), ctx);
+            }
+            if (!firstDispatchDone) {
+                firstDispatchDone = true;
+                activation.ledger.recordActivation(activation.clock);
+            }
+            return {
+                systemPrompt: [
+                    event.systemPrompt,
+                    "",
+                    "<collector_soul>",
+                    activation.soul,
+                    "</collector_soul>",
+                    "",
+                    buildMethodContext(activation),
+                ].join("\n"),
+            };
+        });
+        pi.on("tool_call", (event) => {
+            if (activation === undefined)
+                return;
+            if (activation.ledger.fatal) {
+                return {
+                    block: true,
+                    reason: activation.ledger.fatalReason ?? "通进司致命状态",
+                };
+            }
+            if (!COLLECTOR_REQUIRED_TOOLS.includes(event.toolName)) {
+                return {
+                    block: true,
+                    reason: `通进司禁用工具 ${event.toolName}`,
+                };
+            }
+            if (event.toolName === COLLECTOR_OUTPUT_TOOL) {
+                activation.ledger.beginOperational(COLLECTOR_OUTPUT_TOOL, event.toolCallId);
+            }
+            if (activation.ledger.outputCandidate &&
+                event.toolName !== COLLECTOR_OUTPUT_TOOL) {
+                return {
+                    block: true,
+                    reason: "通进司已产出输出候选，本局不再受理操作",
+                };
+            }
+            return undefined;
+        });
+        pi.on("tool_result", (event) => {
+            if (activation === undefined)
+                return;
+            activation.ledger.completeOperational(event.toolCallId);
+        });
+        pi.on("session_shutdown", () => {
+            if (activation === undefined)
+                return;
+            if (activation.ledger.fatal) {
+                if (process.exitCode === undefined || process.exitCode === 0) {
+                    process.exitCode = 1;
+                }
+            }
+        });
+    };
+    const registerTools = () => {
+        if (toolsRegistered)
+            return;
+        toolsRegistered = true;
+        pi.registerTool({
+            name: COLLECTOR_OBSERVE_TOOL,
+            label: "通进司观察",
+            description: "抓取配置目标的完整 GitHub PR 证据，存不可变快照入卷。正文在上下文中只给头部摘录加指针；需要头部之外的正文时，用 ak_collector_read 按 evidenceId 开卷；findings 的拆分与归类由你在交件时完成。",
+            promptSnippet: "抓取配置目标 PR 证据",
+            parameters: observeSchema,
+            async execute(toolCallId, _params, signal, _onUpdate, ctx) {
+                if (activation === undefined) {
+                    throw new Error("通进司未激活");
+                }
+                try {
+                    activation.ledger.beginOperational(COLLECTOR_OBSERVE_TOOL, toolCallId);
+                    const { snapshot, contextView } = await activation.ledger.observe(activation.transport, activation.clock, signal);
+                    activation.ledger.completeOperational(toolCallId);
+                    if (snapshot.prState !== "OPEN") {
+                        // Non-OPEN observed as latest complete snapshot is target-state failure at output,
+                        // but observe itself may return the fact. If this is a final observation, still return.
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                // #641 chain①: model context carries bounded body heads + pointers only.
+                                text: JSON.stringify(contextView),
+                            }],
+                        // #641 the bounded projection is the only provider-visible face on every host
+                        // (Grok/ACP relays tool details as MCP structuredContent); full bodies stay
+                        // in the ledger volume and enter context only by explicit ak_collector_read.
+                        details: contextView,
+                    };
+                }
+                catch (error) {
+                    hostActions.failInfrastructure(error, ctx, toolCallId);
+                }
+            },
+        });
+        pi.registerTool({
+            name: COLLECTOR_READ_TOOL,
+            label: "通进司开卷",
+            description: "按 evidenceId 开卷读取一条已观测材料的全量正文与指针；只在观察头部摘录不足以判读时调用。",
+            promptSnippet: "按指针开卷读材料",
+            parameters: readSchema,
+            async execute(toolCallId, params, _signal, _onUpdate, ctx) {
+                if (activation === undefined) {
+                    throw new Error("通进司未激活");
+                }
+                try {
+                    activation.ledger.beginOperational(COLLECTOR_READ_TOOL, toolCallId);
+                    const record = activation.ledger.getEvidence(params.evidenceId);
+                    if (record === undefined ||
+                        (record.kind !== "review" && record.kind !== "issue_comment" && record.kind !== "review_comment" && record.kind !== "reaction") ||
+                        typeof record.body !== "string") {
+                        throw new CollectorUnknownEvidenceError(params.evidenceId);
+                    }
+                    const material = projectEvidenceEntryView(record);
+                    activation.ledger.completeOperational(toolCallId);
+                    return {
+                        content: [{
+                                type: "text",
+                                // #641 chain①: full bodies enter provider context only by explicit pointer.
+                                text: JSON.stringify(material),
+                            }],
+                        details: material,
+                    };
+                }
+                catch (error) {
+                    if (isCorrectableExecuteError(error))
+                        throw error;
+                    // typed toolCallId books the shared infrastructure fact so settlement can
+                    // tell a read tool's real host failure from a correctable pointer bounce.
+                    hostActions.failInfrastructure(error, ctx, toolCallId);
+                }
+            },
+        });
+        pi.registerTool({
+            name: COLLECTOR_REQUEST_TOOL,
+            label: "通进司请求",
+            description: "按配置请求体与关联标记，在所引最新快照 HEAD 发一次请求。",
+            promptSnippet: "按配置发一次请求",
+            parameters: requestSchema,
+            async execute(toolCallId, params, signal, _onUpdate, ctx) {
+                if (activation === undefined) {
+                    throw new Error("通进司未激活");
+                }
+                try {
+                    activation.ledger.beginOperational(COLLECTOR_REQUEST_TOOL, toolCallId);
+                    const details = await activation.ledger.request(params, activation.transport, activation.clock, signal);
+                    activation.ledger.completeOperational(toolCallId);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `请求尝试已记录：request ${params.requestId}`,
+                            }],
+                        details,
+                    };
+                }
+                catch (error) {
+                    hostActions.failInfrastructure(error, ctx, toolCallId);
+                }
+            },
+        });
+        pi.registerTool({
+            name: COLLECTOR_WAIT_TOOL,
+            label: "通进司等待",
+            description: "再观察前等待；单次上限五分钟且不超剩余资格。",
+            promptSnippet: "资格截止前等待",
+            parameters: waitSchema,
+            async execute(toolCallId, params, signal, _onUpdate, ctx) {
+                if (activation === undefined) {
+                    throw new Error("通进司未激活");
+                }
+                try {
+                    activation.ledger.beginOperational(COLLECTOR_WAIT_TOOL, toolCallId);
+                    const details = await activation.ledger.wait(params, activation.clock, signal);
+                    activation.ledger.completeOperational(toolCallId);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `已等待 ${String(details.effectiveMs)}ms`,
+                            }],
+                        details,
+                    };
+                }
+                catch (error) {
+                    hostActions.failInfrastructure(error, ctx, toolCallId);
+                }
+            },
+        });
+        pi.registerTool({
+            name: COLLECTOR_OUTPUT_TOOL,
+            label: "通进司输出",
+            description: "观察完成后提交；回执由 runtime 组装。正常完工提交空对象 {}（如需报 finding，填 findings 指针数组）；仅在基础设施真实失败时才可填 infrastructureFailure，无失败时必须省略该字段。",
+            promptSnippet: "提交通进司回执",
+            // #641 chain②: the seat owns the normal-completion decision. The probe
+            // runs the exact receipt assembly (validation only, no accept side
+            // effects); success ⇒ machine-verified normal completion ⇒ bounce.
+            bounceInfrastructureDeclaration(params) {
+                if (activation === undefined)
+                    return undefined;
+                try {
+                    buildCollectorReceipt(activation.ledger, params, activation.clock);
+                }
+                catch {
+                    return undefined;
+                }
+                return new CollectorNormalCompletionDeclarationError();
+            },
+            parameters: outputSchema,
+            async execute(toolCallId, params, _signal, _onUpdate, ctx) {
+                if (activation === undefined) {
+                    throw new Error("通进司未激活");
+                }
+                try {
+                    activation.ledger.beginOperational(COLLECTOR_OUTPUT_TOOL, toolCallId);
+                    const receipt = buildCollectorReceipt(activation.ledger, params, activation.clock);
+                    activation.ledger.recordOutputCandidate();
+                    const acceptedDetails = receipt;
+                    return {
+                        content: [{
+                                type: "text",
+                                text: COLLECTOR_ACCEPTED_TEXT,
+                            }],
+                        details: acceptedDetails,
+                        terminate: true,
+                    };
+                }
+                catch (error) {
+                    // Output validation errors are model-visible rejections when non-fatal.
+                    if (error instanceof Error &&
+                        error.collectorFatal === true) {
+                        hostActions.failInfrastructure(error, ctx, toolCallId);
+                    }
+                    throw error;
+                }
+                finally {
+                    activation.ledger.completeOperational(toolCallId);
+                }
+            },
+        });
+    };
+    return {
+        async activate(ctx, event) {
+            activation = undefined;
+            ensureLifecycle();
+            if (ctx.mode !== "print" && ctx.mode !== "json") {
+                throw new Error(`Collector supports only print or json mode (got ${ctx.mode})`);
+            }
+            if (event.reason === "fork" ||
+                event.reason === "reload") {
+                throw new Error(`Collector does not support session_start reason ${event.reason}`);
+            }
+            const soul = (await dependencies.loadSoul()).trim();
+            if (soul.length === 0)
+                throw new Error("Collector soul is empty");
+            const repoFlag = pi.getFlag("ak-collector-repo");
+            const prFlag = pi.getFlag("ak-collector-pr");
+            const requestManifestFlag = pi.getFlag("ak-collector-request-manifest");
+            if (typeof repoFlag !== "string" || repoFlag.trim().length === 0) {
+                throw new Error("Collector requires --ak-collector-repo");
+            }
+            if (typeof prFlag !== "string" && typeof prFlag !== "number") {
+                throw new Error("Collector requires --ak-collector-pr");
+            }
+            const repository = parseCollectorRepository(repoFlag);
+            const prNumber = parseCollectorPrNumber(prFlag);
+            const manifest = typeof requestManifestFlag === "string" && requestManifestFlag.trim().length > 0
+                ? await loadCollectorManifest(requestManifestFlag)
+                : emptyCollectorManifest();
+            // Detectable ambient command surface (skills/templates) when exposed.
+            const commands = pi.getCommands?.() ?? [];
+            const ambientCommands = commands.filter((command) => {
+                const name = command.name.toLowerCase();
+                return (name.includes("skill") ||
+                    name.includes("prompt") ||
+                    name.startsWith("template"));
+            });
+            if (ambientCommands.length > 0) {
+                throw new Error(`Collector detected ambient instruction commands: ${ambientCommands.map((c) => c.name).join(", ")}`);
+            }
+            // Fail closed if a required name is already occupied before Collector registers.
+            const preExisting = pi.getAllTools();
+            for (const required of COLLECTOR_REQUIRED_TOOLS) {
+                const prior = preExisting.filter((tool) => tool.name === required);
+                if (prior.length > 0) {
+                    throw new Error(`Collector required tool name collision: ${required}`);
+                }
+            }
+            registerTools();
+            const allTools = pi.getAllTools();
+            for (const required of COLLECTOR_REQUIRED_TOOLS) {
+                const matches = allTools.filter((tool) => tool.name === required);
+                if (matches.length === 0) {
+                    throw new Error(`Collector required tool missing: ${required}`);
+                }
+                if (matches.length > 1) {
+                    throw new Error(`Collector required tool name collision: ${required}`);
+                }
+                const tool = matches[0];
+                if (dependencies.packageExtensionPath !== undefined &&
+                    tool.sourceInfo?.path !== undefined &&
+                    tool.sourceInfo.path !== dependencies.packageExtensionPath &&
+                    !tool.sourceInfo.path.includes("role-runtime")) {
+                    throw new Error(`Collector required tool ${required} is overridden by ${tool.sourceInfo.path}`);
+                }
+            }
+            pi.setActiveTools([...COLLECTOR_REQUIRED_TOOLS]);
+            const active = new Set(pi.getActiveTools());
+            for (const required of COLLECTOR_REQUIRED_TOOLS) {
+                if (!active.has(required)) {
+                    throw new Error(`Collector failed to activate required tool ${required}`);
+                }
+            }
+            for (const name of active) {
+                if (!COLLECTOR_REQUIRED_TOOLS.includes(name)) {
+                    throw new Error(`Collector active tool surface includes unexpected ${name}`);
+                }
+            }
+            const clock = dependencies.createClock?.() ?? createSystemCollectorClock();
+            const transport = dependencies.createTransport();
+            const ledger = dependencies.createLedger({ repository, prNumber, manifest }, clock, ctx);
+            if (ledger.activationRecorded) {
+                firstDispatchDone = true;
+            }
+            activation = {
+                soul,
+                repository,
+                prNumber,
+                manifest,
+                ledger,
+                transport,
+                clock,
+            };
+        },
+    };
+}

package/dist/compliance-transport.js

@@ -1,19 +1,5 @@
 import { Type } from "typebox";
 import { auditorRunDirectory } from "./auditor-dossier-tool.js";
-import { retainedShapeUnreadable } from "./shape-unreadable-failure.js";
-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 !== void 0) this.usage = usage;
-  }
-}
 const AUDITOR_DOSSIER_PROMPT = "\u672C run \u5377\u5B97\u5DF2\u5C31\u7EEA\u3002";
 const nonblank = Type.String({ minLength: 1, pattern: "\\S" });
 const decisionGateSchema = Type.Object({ question: nonblank, options: Type.Array(nonblank, { minItems: 1 }) }, { additionalProperties: false });
@@ -51,45 +37,16 @@ function tryReadComplianceCandidate(arguments_, usage) {
 function readComplianceCandidate(arguments_, usage) {
   const projected = tryReadComplianceCandidate(arguments_, usage);
   if (projected !== void 0) return projected;
-  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 status = arguments_.status;
-  throw new ComplianceCandidateUnreadableError(
-    { kind: "object-status-unreadable", status: status === void 0 ? "missing" : "unknown" },
-    arguments_,
-    usage
-  );
+  return {
+    status: "received",
+    reply: arguments_,
+    ...usage === void 0 ? {} : { usage }
+  };
 }
 async function usageFromSummonedSession(summoned) {
   const { usageFromPublicSummon } = await import("./session-assistant-usage.js");
   return usageFromPublicSummon(summoned);
 }
-function observationFromUnreadableCandidate(candidate) {
-  if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
-    return {
-      kind: "non-object-arguments",
-      type: candidate === null ? "null" : Array.isArray(candidate) ? "array" : typeof candidate
-    };
-  }
-  const status = candidate.status;
-  return {
-    kind: "object-status-unreadable",
-    status: status === void 0 ? "missing" : "unknown"
-  };
-}
-function unreadableDecision(candidate, usage) {
-  return {
-    status: "unreadable",
-    observation: observationFromUnreadableCandidate(candidate),
-    candidate,
-    ...usage === void 0 ? {} : { usage }
-  };
-}
 async function projectAuditorTerminal(summoned) {
   const outcome = summoned.terminal?.roleOutcome;
   if (outcome === void 0) {
@@ -105,10 +62,6 @@ async function projectAuditorTerminal(summoned) {
     };
   }
   if (outcome.kind === "failure") {
-    const shape = retainedShapeUnreadable(outcome.decisiveFacts);
-    if (shape !== void 0) {
-      return unreadableDecision(shape.candidate, usage);
-    }
     throw new Error(outcome.diagnostic);
   }
   if (outcome.kind === "accepted") {
@@ -116,11 +69,13 @@ async function projectAuditorTerminal(summoned) {
       status: outcome.status,
       ...outcome.decisiveFacts
     };
-    const projected = tryReadComplianceCandidate(candidate, usage);
-    if (projected !== void 0) return projected;
-    return unreadableDecision(candidate, usage);
+    return readComplianceCandidate(candidate, usage);
   }
-  throw new Error("Auditor public summon returned unusable terminal kind");
+  return {
+    status: "received",
+    reply: outcome,
+    ...usage === void 0 ? {} : { usage }
+  };
 }
 async function runComplianceAudit(options) {
   const runDirectory = options.runDirectory ?? auditorRunDirectory(options.context);
@@ -154,7 +109,6 @@ export {
   AUDITOR_DOSSIER_PROMPT,
   AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE,
   COMPLIANCE_RESPONSE_ENTRY_TYPE,
-  ComplianceCandidateUnreadableError,
   ComplianceResponseRetentionError,
   complianceDecisionSchema,
   readComplianceCandidate,

package/dist/countersign-role.js

@@ -0,0 +1,28 @@
+import { Type } from "typebox";
+import { stringEnum } from "./host-contracts.js";
+import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.js";
+import { COUNTERSIGN_OUTPUT_TOOL_NAME, validateRecordedCountersignOutput, } from "./countersign-contracts.js";
+export { COUNTERSIGN_ACCEPTED_TEXT, COUNTERSIGN_OUTPUT_TOOL_NAME } from "./countersign-contracts.js";
+/** 给事中票庭审读五问的交卷形状（ADR 0074）；形状指引，非 schema 闸。 */
+export const countersignVerdictSchema = withInfrastructureFailureDeclaration(Type.Object({
+    countersignStatus: stringEnum(["converged", "continue", "escalate"], { description: "converged | continue | escalate" }),
+    fix: Type.Optional(Type.Object({ summary: Type.String({ minLength: 1, description: "退回摘要" }) }, { additionalProperties: false, description: "退回说明" })),
+    note: Type.Optional(Type.String({ minLength: 1, description: "附注" })),
+    evidence: Type.Optional(Type.Unknown({ description: "留存证据" })),
+    decisionGate: Type.Optional(Type.Object({
+        question: Type.String({ minLength: 1 }),
+        options: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+    }, { additionalProperties: false, description: "需陛下处置的问题与选项" })),
+}, { additionalProperties: true }));
+countersignVerdictSchema.required = [];
+/**
+ * 决定工具规格。生命周期装配（注册、activate、prompt 注入、singleton 检查、
+ * terminate）归注册信封 owner——src/role-runtime.ts（ADR 0018 / #572 R2 判词）。
+ */
+export const COUNTERSIGN_TOOL_SPEC = {
+    name: COUNTERSIGN_OUTPUT_TOOL_NAME,
+    label: "给事中输出",
+    description: "给事中决议。",
+    promptSnippet: "给事中决议",
+    parameters: countersignVerdictSchema,
+};

package/dist/diarist-contracts.js

@@ -58,15 +58,3 @@ export function projectDiaristSelections(value) {
     }
     return out;
 }
-/** Machine-facing facts from an accepted receipt. Submitted rows retained as-is. */
-export function diaristDecisiveFacts(output) {
-    const facts = { status: output.status };
-    const selections = output.selections;
-    if (Array.isArray(selections))
-        facts.selections = selections;
-    // Mechanical sitian facts recorded by the envelope at accept time.
-    const sitian = output.sitian;
-    if (sitian !== undefined)
-        facts.sitian = sitian;
-    return facts;
-}

package/dist/diarist-role.js

@@ -0,0 +1,29 @@
+import { Type } from "typebox";
+import { openToolObject } from "./open-tool-schema.js";
+import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.js";
+import { DIARIST_OUTPUT_TOOL_NAME, validateRecordedDiaristOutput, } from "./diarist-contracts.js";
+export { DIARIST_ACCEPTED_TEXT, DIARIST_OUTPUT_TOOL_NAME, } from "./diarist-contracts.js";
+export { validateRecordedDiaristOutput };
+/** 起居郎交卷形状；形状指引，非 schema 闸。 */
+export const diaristOutputSchema = withInfrastructureFailureDeclaration(openToolObject(Type.Object({
+    status: Type.Unknown({
+        description: "completed — 形状指引，非 schema 闸",
+    }),
+    selections: Type.Array(Type.Object({
+        candidateIndex: Type.Number({ description: "候选目录中的整块序号" }),
+        quotes: Type.Array(Type.String(), {
+            description: "该块 transcript 内的连续原文；机械反验",
+        }),
+        note: Type.Optional(Type.String({ description: "该材料与本案的关系（人读）" })),
+    }, { additionalProperties: true, description: "一条入录选择" }), { description: "入录选择；空列表合法完局" }),
+})));
+/**
+ * 决定工具规格。生命周期装配归注册信封 owner——src/role-runtime.ts（ADR 0018）。
+ */
+export const DIARIST_TOOL_SPEC = {
+    name: DIARIST_OUTPUT_TOOL_NAME,
+    label: "起居郎输出",
+    description: "起居郎入录选择。",
+    promptSnippet: "起居郎入录选择",
+    parameters: diaristOutputSchema,
+};

package/dist/doctor-contracts.js

@@ -6,7 +6,6 @@ const DOCTOR_EVIDENCE_TOOL_NAME = "ak_doctor_evidence";
 const DOCTOR_OUTPUT_TOOL_NAME = "ak_doctor_output";
 const DOCTOR_ACCEPTED_TEXT = "\u592A\u533B\u7F72\u56DE\u6267\u5DF2\u63A5\u53D7";
 const DOCTOR_ACCEPTED_AUDIT_NO_RECEIPT_TEXT = "\u592A\u533B\u7F72\u56DE\u6267\u5DF2\u63A5\u53D7\uFF1B\u5BA1\u8BA1\u65E0\u56DE\u6267";
-const DOCTOR_ACCEPTED_AUDIT_UNREADABLE_TEXT = "\u592A\u533B\u7F72\u56DE\u6267\u5DF2\u63A5\u53D7\uFF1B\u5BA1\u8BA1\u5F62\u72B6\u4E0D\u53EF\u8BFB";
 const DOCTOR_OUTPUT_TOOL_DESCRIPTION = "\u63D0\u4EA4\u552F\u4E00\u7EC8\u5C40\u5355\u6848\u8BC1\u8BCD\uFF1Bcompleted \u5141\u8BB8\u7A7A findings\uFF1Bruntime \u8865\u8BB0\u6D3E\u751F\u6210\u672C\u5165\u56DE\u6267\u3002";
 const DOCTOR_TARGET_KINDS = ["law", "gate", "template", "station", "seat"];
 const nonblank = Type.String({ minLength: 1, pattern: "\\S" });
@@ -185,7 +184,6 @@ function validateDoctorOutput(value, patient, store) {
 }
 export {
   DOCTOR_ACCEPTED_AUDIT_NO_RECEIPT_TEXT,
-  DOCTOR_ACCEPTED_AUDIT_UNREADABLE_TEXT,
   DOCTOR_ACCEPTED_TEXT,
   DOCTOR_EVIDENCE_TOOL_NAME,
   DOCTOR_OUTPUT_TOOL_DESCRIPTION,