@akagilnc/pi-workflow-roles 0.1.3414 → 0.1.3439

package/dist/countersign-contracts.js

@@ -1,27 +1,25 @@
-/**
- * Public Countersign (给事中) terminating receipt contracts.
- * Lawful verdicts: converged (署) | continue (封驳) | escalate (上呈).
- * (#572 / ADR 0074) — 原卷保真: the verdict is recognized read-only; no field
- * is defaulted, rewritten, or dropped (ADR 0055).
- */
-export const COUNTERSIGN_OUTPUT_TOOL_NAME = "ak_countersign_output";
-export const COUNTERSIGN_ACCEPTED_TEXT = "给事中回执已接受";
-export function validateRecordedCountersignOutput(verdict) {
-    if (verdict === null || typeof verdict !== "object" || Array.isArray(verdict)) {
-        throw new Error("Countersign verdict has no execution discriminator");
-    }
-    let countersignStatus;
-    try {
-        countersignStatus = verdict.countersignStatus;
-    }
-    catch {
-        throw new Error("Countersign verdict has no execution discriminator");
-    }
-    if (typeof countersignStatus !== "string") {
-        throw new Error("Countersign verdict has no execution discriminator");
-    }
-    if (["converged", "continue", "escalate"].includes(countersignStatus)) {
-        return verdict;
-    }
+const COUNTERSIGN_OUTPUT_TOOL_NAME = "ak_countersign_output";
+const COUNTERSIGN_ACCEPTED_TEXT = "\u7ED9\u4E8B\u4E2D\u56DE\u6267\u5DF2\u63A5\u53D7";
+function validateRecordedCountersignOutput(verdict) {
+  if (verdict === null || typeof verdict !== "object" || Array.isArray(verdict)) {
     throw new Error("Countersign verdict has no execution discriminator");
+  }
+  let countersignStatus;
+  try {
+    countersignStatus = verdict.countersignStatus;
+  } catch {
+    throw new Error("Countersign verdict has no execution discriminator");
+  }
+  if (typeof countersignStatus !== "string") {
+    throw new Error("Countersign verdict has no execution discriminator");
+  }
+  if (["converged", "continue", "escalate"].includes(countersignStatus)) {
+    return verdict;
+  }
+  throw new Error("Countersign verdict has no execution discriminator");
 }
+export {
+  COUNTERSIGN_ACCEPTED_TEXT,
+  COUNTERSIGN_OUTPUT_TOOL_NAME,
+  validateRecordedCountersignOutput
+};

package/dist/doctor-contracts.js

@@ -2,175 +2,199 @@ import { Type } from "typebox";
 import { canonicalJson } from "./canonical-json.js";
 import { openToolObjectFromUnion } from "./open-tool-schema.js";
 import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.js";
-export const DOCTOR_EVIDENCE_TOOL_NAME = "ak_doctor_evidence";
-export const DOCTOR_OUTPUT_TOOL_NAME = "ak_doctor_output";
-export const DOCTOR_ACCEPTED_TEXT = "太医署回执已接受";
-export const DOCTOR_ACCEPTED_AUDIT_NO_RECEIPT_TEXT = "太医署回执已接受；审计无回执";
-export const DOCTOR_OUTPUT_TOOL_DESCRIPTION = "提交唯一终局单案证词；completed 允许空 findings；runtime 补记派生成本入回执。";
-export const DOCTOR_TARGET_KINDS = ["law", "gate", "template", "station", "seat"];
+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_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" });
 const count = Type.Object({ count: Type.Integer({ minimum: 0 }), sources: Type.Array(nonblank) }, { additionalProperties: false });
 const evidenceIds = Type.Array(nonblank, { minItems: 1 });
 const guardrail = Type.Object({ answer: Type.Boolean(), evidenceIds, explanation: nonblank }, { additionalProperties: false });
 const lastRealBite = Type.Union([
-    Type.Object({ kind: Type.Literal("actual"), targetKey: nonblank, evidenceId: nonblank }, { additionalProperties: false }),
-    Type.Object({ kind: Type.Literal("noRealBite"), targetKey: nonblank, eligibleEvidenceIds: evidenceIds }, { additionalProperties: false }),
+  Type.Object({ kind: Type.Literal("actual"), targetKey: nonblank, evidenceId: nonblank }, { additionalProperties: false }),
+  Type.Object({ kind: Type.Literal("noRealBite"), targetKey: nonblank, eligibleEvidenceIds: evidenceIds }, { additionalProperties: false })
 ]);
 const assetKinds = DOCTOR_TARGET_KINDS;
 const findingBody = {
-    evidenceIds, disposition: Type.Union([Type.Literal("keep"), Type.Literal("thin"), Type.Literal("delete")]),
-    guardrails: Type.Object({ reproducibleFailure: guardrail, owningSeamOrInvariant: guardrail, deletionOrSimplificationSuffices: guardrail }, { additionalProperties: true }),
-    prescription: Type.Object({ kind: Type.Union([Type.Literal("retain"), Type.Literal("delete"), Type.Literal("simplify"), Type.Literal("patch"), Type.Literal("addMechanism")]), recommendation: nonblank, necessityExplanation: Type.Optional(nonblank) }, { additionalProperties: false }), lastRealBite,
+  evidenceIds,
+  disposition: Type.Union([Type.Literal("keep"), Type.Literal("thin"), Type.Literal("delete")]),
+  guardrails: Type.Object({ reproducibleFailure: guardrail, owningSeamOrInvariant: guardrail, deletionOrSimplificationSuffices: guardrail }, { additionalProperties: true }),
+  prescription: Type.Object({ kind: Type.Union([Type.Literal("retain"), Type.Literal("delete"), Type.Literal("simplify"), Type.Literal("patch"), Type.Literal("addMechanism")]), recommendation: nonblank, necessityExplanation: Type.Optional(nonblank) }, { additionalProperties: false }),
+  lastRealBite
 };
 const finding = Type.Union([
-    Type.Object({ targetKey: nonblank, observation: nonblank, evidenceIds }, { additionalProperties: false }),
-    Type.Object({ targetKey: nonblank, targetKind: Type.Union(assetKinds.map((kind) => Type.Literal(kind))), assetEvidence: Type.Object({ targetKey: nonblank, targetKind: Type.Union(assetKinds.map((kind) => Type.Literal(kind))), evidenceId: nonblank }, { additionalProperties: false }), ...findingBody }, { additionalProperties: false }),
+  Type.Object({ targetKey: nonblank, observation: nonblank, evidenceIds }, { additionalProperties: false }),
+  Type.Object({ targetKey: nonblank, targetKind: Type.Union(assetKinds.map((kind) => Type.Literal(kind))), assetEvidence: Type.Object({ targetKey: nonblank, targetKind: Type.Union(assetKinds.map((kind) => Type.Literal(kind))), evidenceId: nonblank }, { additionalProperties: false }), ...findingBody }, { additionalProperties: false })
 ]);
 const caseIdentity = Type.Object({ issueNumber: Type.Integer({ minimum: 1 }), runsPath: nonblank }, { additionalProperties: false });
 const cost = Type.Object({
-    invocations: count, legs: count, modelApiTurns: count, outputTokens: count, toolCalls: count,
-    retries: Type.Object({ count: Type.Integer({ minimum: 0 }), sources: Type.Array(nonblank), evidence: Type.Literal("literal run-dir naming") }, { additionalProperties: false }),
-    statuses: Type.Array(Type.Object({ source: nonblank, status: nonblank }, { additionalProperties: false })),
-    commits: Type.Array(Type.Object({ source: nonblank, commit: nonblank }, { additionalProperties: false })),
-    sessions: Type.Array(Type.Union([
-        Type.Object({ source: nonblank, startedAt: nonblank, endedAt: nonblank, wallMilliseconds: Type.Number({ minimum: 0 }), completion: Type.Literal("accepted") }, { additionalProperties: false }),
-        Type.Object({ source: nonblank, startedAt: Type.Optional(nonblank), endedAt: Type.Optional(nonblank), wallMilliseconds: Type.Optional(Type.Number({ minimum: 0 })), completion: Type.Literal("incomplete"), degradationReason: Type.Optional(nonblank) }, { additionalProperties: false }),
-    ])),
-    outputBytes: Type.Object({ count: Type.Integer({ minimum: 0 }), sources: Type.Array(nonblank), payload: Type.Literal("raw JSONL bytes"), providerWireBytes: Type.Literal("unavailable") }, { additionalProperties: false }),
+  invocations: count,
+  legs: count,
+  modelApiTurns: count,
+  outputTokens: count,
+  toolCalls: count,
+  retries: Type.Object({ count: Type.Integer({ minimum: 0 }), sources: Type.Array(nonblank), evidence: Type.Literal("literal run-dir naming") }, { additionalProperties: false }),
+  statuses: Type.Array(Type.Object({ source: nonblank, status: nonblank }, { additionalProperties: false })),
+  commits: Type.Array(Type.Object({ source: nonblank, commit: nonblank }, { additionalProperties: false })),
+  sessions: Type.Array(Type.Union([
+    Type.Object({ source: nonblank, startedAt: nonblank, endedAt: nonblank, wallMilliseconds: Type.Number({ minimum: 0 }), completion: Type.Literal("accepted") }, { additionalProperties: false }),
+    Type.Object({ source: nonblank, startedAt: Type.Optional(nonblank), endedAt: Type.Optional(nonblank), wallMilliseconds: Type.Optional(Type.Number({ minimum: 0 })), completion: Type.Literal("incomplete"), degradationReason: Type.Optional(nonblank) }, { additionalProperties: false })
+  ])),
+  outputBytes: Type.Object({ count: Type.Integer({ minimum: 0 }), sources: Type.Array(nonblank), payload: Type.Literal("raw JSONL bytes"), providerWireBytes: Type.Literal("unavailable") }, { additionalProperties: false })
 }, { additionalProperties: false });
 const doctorSubmissionVariants = Type.Union([
-    Type.Object({
-        status: Type.Literal("completed", { description: "completed — 形状指引，非 schema 闸；允许空 findings；runtime 补记派生成本入回执" }),
-        case: Type.Unsafe({ ...caseIdentity, description: "留存太医署案身份" }),
-        findings: Type.Array(finding, { description: "可空或仅含非处方案观察；缺可复用资产或 bounded-bite 证据只排除对应资产处方" }),
-    }, { additionalProperties: false, description: "单案证词，不要求任何处方或可复用 finding" }),
-    Type.Object({
-        status: Type.Literal("refused", { description: "refused — 形状指引，非 schema 闸；仅当证据不足以支撑如实案证词" }),
-        reason: Type.String({ minLength: 1, description: "证据不足以支撑如实证词的原因" }),
-        missingEvidence: Type.Array(Type.Object({ need: nonblank, targetKeys: Type.Array(nonblank, { minItems: 1 }) }, { additionalProperties: false }), { minItems: 1, description: "如实证词所需而尚缺的证据" }),
-    }, { additionalProperties: false, description: "证据不足以支撑如实案证词" }),
+  Type.Object({
+    status: Type.Literal("completed", { description: "completed \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\uFF1B\u5141\u8BB8\u7A7A findings\uFF1Bruntime \u8865\u8BB0\u6D3E\u751F\u6210\u672C\u5165\u56DE\u6267" }),
+    case: Type.Unsafe({ ...caseIdentity, description: "\u7559\u5B58\u592A\u533B\u7F72\u6848\u8EAB\u4EFD" }),
+    findings: Type.Array(finding, { description: "\u53EF\u7A7A\u6216\u4EC5\u542B\u975E\u5904\u65B9\u6848\u89C2\u5BDF\uFF1B\u7F3A\u53EF\u590D\u7528\u8D44\u4EA7\u6216 bounded-bite \u8BC1\u636E\u53EA\u6392\u9664\u5BF9\u5E94\u8D44\u4EA7\u5904\u65B9" })
+  }, { additionalProperties: false, description: "\u5355\u6848\u8BC1\u8BCD\uFF0C\u4E0D\u8981\u6C42\u4EFB\u4F55\u5904\u65B9\u6216\u53EF\u590D\u7528 finding" }),
+  Type.Object({
+    status: Type.Literal("refused", { description: "refused \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\uFF1B\u4EC5\u5F53\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u6848\u8BC1\u8BCD" }),
+    reason: Type.String({ minLength: 1, description: "\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u8BC1\u8BCD\u7684\u539F\u56E0" }),
+    missingEvidence: Type.Array(Type.Object({ need: nonblank, targetKeys: Type.Array(nonblank, { minItems: 1 }) }, { additionalProperties: false }), { minItems: 1, description: "\u5982\u5B9E\u8BC1\u8BCD\u6240\u9700\u800C\u5C1A\u7F3A\u7684\u8BC1\u636E" })
+  }, { additionalProperties: false, description: "\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u6848\u8BC1\u8BCD" })
 ]);
-export const doctorSubmissionSchema = withInfrastructureFailureDeclaration(openToolObjectFromUnion(doctorSubmissionVariants));
-export const doctorOutputSchema = Type.Union([
-    Type.Object({ status: Type.Literal("completed"), case: caseIdentity, findings: Type.Array(finding), cost }, { additionalProperties: false }),
-    doctorSubmissionVariants.anyOf[1],
+const doctorSubmissionSchema = withInfrastructureFailureDeclaration(
+  openToolObjectFromUnion(doctorSubmissionVariants)
+);
+const doctorOutputSchema = Type.Union([
+  Type.Object({ status: Type.Literal("completed"), case: caseIdentity, findings: Type.Array(finding), cost }, { additionalProperties: false }),
+  doctorSubmissionVariants.anyOf[1]
 ]);
-export const doctorEvidenceReadSchema = Type.Object({ evidenceId: Type.String({ minLength: 1, description: "待读留存证据标识" }), offset: Type.Optional(Type.Integer({ minimum: 0, description: "起始字节偏移（从 0 计）" })), limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 4096, description: "返回字节上限" })) }, { additionalProperties: false });
-export class DoctorSubmissionContractError extends Error {
-    name = "DoctorSubmissionContractError";
+const doctorEvidenceReadSchema = Type.Object({ evidenceId: Type.String({ minLength: 1, description: "\u5F85\u8BFB\u7559\u5B58\u8BC1\u636E\u6807\u8BC6" }), offset: Type.Optional(Type.Integer({ minimum: 0, description: "\u8D77\u59CB\u5B57\u8282\u504F\u79FB\uFF08\u4ECE 0 \u8BA1\uFF09" })), limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 4096, description: "\u8FD4\u56DE\u5B57\u8282\u4E0A\u9650" })) }, { additionalProperties: false });
+class DoctorSubmissionContractError extends Error {
+  name = "DoctorSubmissionContractError";
 }
-function isRecord(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
-function read(value, key) { if (!isRecord(value))
-    return undefined; try {
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function read(value, key) {
+  if (!isRecord(value)) return void 0;
+  try {
     return value[key];
+  } catch {
+    return void 0;
+  }
 }
-catch {
-    return undefined;
-} }
-export function validateDoctorSubmissionShape(value) {
-    const status = read(value, "status");
-    if (status !== "completed" && status !== "refused")
-        throw new DoctorSubmissionContractError("太医署交卷无已识别的执行状态");
-    return value;
+function validateDoctorSubmissionShape(value) {
+  const status = read(value, "status");
+  if (status !== "completed" && status !== "refused") throw new DoctorSubmissionContractError("\u592A\u533B\u7F72\u4EA4\u5377\u65E0\u5DF2\u8BC6\u522B\u7684\u6267\u884C\u72B6\u6001");
+  return value;
 }
-export function validateRecordedDoctorOutput(value) {
-    const output = validateDoctorSubmissionShape(value);
-    const status = read(output, "status");
-    if (status === "completed" && read(output, "cost") === undefined)
-        throw new DoctorSubmissionContractError("completed 太医署回执缺少 runtime 持有的 cost 证词");
-    return output;
+function validateRecordedDoctorOutput(value) {
+  const output = validateDoctorSubmissionShape(value);
+  const status = read(output, "status");
+  if (status === "completed" && read(output, "cost") === void 0) throw new DoctorSubmissionContractError("completed \u592A\u533B\u7F72\u56DE\u6267\u7F3A\u5C11 runtime \u6301\u6709\u7684 cost \u8BC1\u8BCD");
+  return output;
 }
-export class DoctorEvidenceStore {
-    patient;
-    entries;
-    coverage = new Map();
-    constructor(patient) {
-        this.patient = patient;
-        this.entries = new Map(patient.evidence.map((entry) => [entry.id, entry]));
+class DoctorEvidenceStore {
+  constructor(patient) {
+    this.patient = patient;
+    this.entries = new Map(patient.evidence.map((entry) => [entry.id, entry]));
+  }
+  patient;
+  entries;
+  coverage = /* @__PURE__ */ new Map();
+  read(evidenceId, offset = 0, limit = 4096) {
+    const entry = this.entries.get(evidenceId);
+    if (!entry) throw new Error(`\u8BC1\u636E ID \u672A\u51C6\u5165\uFF1A${evidenceId}`);
+    if (!Number.isInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 1 || limit > 4096) throw new Error("\u8BC1\u636E\u5206\u9875\u53C2\u6570\u65E0\u6548");
+    if (offset > entry.contentLength) throw new Error("\u8BC1\u636E offset \u8D85\u51FA\u5185\u5BB9");
+    const end = Math.min(entry.contentLength, offset + limit);
+    const ranges = [...this.coverage.get(evidenceId) ?? [], [offset, end]].sort((a, b) => a[0] - b[0]);
+    const merged = [];
+    for (const range of ranges) {
+      const prior = merged.at(-1);
+      if (prior && range[0] <= prior[1]) prior[1] = Math.max(prior[1], range[1]);
+      else merged.push([...range]);
     }
-    read(evidenceId, offset = 0, limit = 4096) { const entry = this.entries.get(evidenceId); if (!entry)
-        throw new Error(`证据 ID 未准入：${evidenceId}`); if (!Number.isInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 1 || limit > 4096)
-        throw new Error("证据分页参数无效"); if (offset > entry.contentLength)
-        throw new Error("证据 offset 超出内容"); const end = Math.min(entry.contentLength, offset + limit); const ranges = [...(this.coverage.get(evidenceId) ?? []), [offset, end]].sort((a, b) => a[0] - b[0]); const merged = []; for (const range of ranges) {
-        const prior = merged.at(-1);
-        if (prior && range[0] <= prior[1])
-            prior[1] = Math.max(prior[1], range[1]);
-        else
-            merged.push([...range]);
-    } this.coverage.set(evidenceId, merged); return { evidenceId, kind: entry.kind, offset, content: entry.content.slice(offset, end), nextOffset: end < entry.contentLength ? end : null, contentLength: entry.contentLength, byteLength: entry.byteLength, sha256: entry.sha256 }; }
-    hasRead(id) { const entry = this.entries.get(id); const ranges = this.coverage.get(id); return !!entry && ranges?.length === 1 && ranges[0][0] === 0 && ranges[0][1] === entry.contentLength; }
-    readRecord() { return [...this.coverage.keys()].sort().map((evidenceId) => ({ evidenceId, fullyRead: this.hasRead(evidenceId) })); }
+    this.coverage.set(evidenceId, merged);
+    return { evidenceId, kind: entry.kind, offset, content: entry.content.slice(offset, end), nextOffset: end < entry.contentLength ? end : null, contentLength: entry.contentLength, byteLength: entry.byteLength, sha256: entry.sha256 };
+  }
+  hasRead(id) {
+    const entry = this.entries.get(id);
+    const ranges = this.coverage.get(id);
+    return !!entry && ranges?.length === 1 && ranges[0][0] === 0 && ranges[0][1] === entry.contentLength;
+  }
+  readRecord() {
+    return [...this.coverage.keys()].sort().map((evidenceId) => ({ evidenceId, fullyRead: this.hasRead(evidenceId) }));
+  }
 }
-export function validateDoctorOutput(value, patient, store) {
-    const output = validateDoctorSubmissionShape(value);
-    const lawfulTargets = new Set(["case", ...patient.cost.invocations.sources]);
-    const assertTarget = (targetKey) => { if (typeof targetKey === "string" && !lawfulTargets.has(targetKey))
-        throw new DoctorSubmissionContractError(`targetKey 不是合法案目标：${targetKey}`); };
-    const readCitations = (ids, label) => { if (!Array.isArray(ids))
-        return; for (const id of ids)
-        if (typeof id === "string" && (!store.entries.has(id) || !store.hasRead(id)))
-            throw new DoctorSubmissionContractError(`${label} 须引用已准入/已读证据：${id}`); };
-    if (read(output, "status") === "refused") {
-        const missingEvidence = read(output, "missingEvidence");
-        if (Array.isArray(missingEvidence))
-            for (const missing of missingEvidence) {
-                const targets = read(missing, "targetKeys");
-                if (Array.isArray(targets))
-                    for (const target of targets)
-                        assertTarget(target);
-            }
-        return output;
-    }
-    const identity = read(output, "case");
-    const issueNumber = read(identity, "issueNumber");
-    const runsPath = read(identity, "runsPath");
-    if ((issueNumber !== undefined && issueNumber !== patient.identity.issueNumber) || (runsPath !== undefined && runsPath !== patient.identity.runsPath))
-        throw new DoctorSubmissionContractError("太医署交卷 case 须等于已激活案身份");
-    const findings = read(output, "findings");
-    if (!Array.isArray(findings))
-        return output;
-    for (const finding of findings) {
-        const targetKey = read(finding, "targetKey");
-        readCitations(read(finding, "evidenceIds"), "finding");
-        const assetEvidence = read(finding, "assetEvidence");
-        if (!isRecord(assetEvidence)) {
-            assertTarget(targetKey);
-            continue;
-        }
-        const assetTargetKey = read(assetEvidence, "targetKey");
-        const assetTargetKind = read(assetEvidence, "targetKind");
-        const assetEvidenceId = read(assetEvidence, "evidenceId");
-        if (typeof assetTargetKey === "string" && assetTargetKey !== targetKey)
-            throw new DoctorSubmissionContractError("类型化资产证据须确立 finding 的 targetKey");
-        if (typeof assetTargetKind === "string" && assetTargetKind !== read(finding, "targetKind"))
-            throw new DoctorSubmissionContractError("类型化资产证据须确立 finding 的 targetKind");
-        if (typeof assetEvidenceId === "string")
-            readCitations([assetEvidenceId], "asset evidence");
-        const guardrails = read(finding, "guardrails");
-        for (const key of ["reproducibleFailure", "owningSeamOrInvariant", "deletionOrSimplificationSuffices"])
-            readCitations(read(read(guardrails, key), "evidenceIds"), "guardrail");
-        const bite = read(finding, "lastRealBite");
-        const biteKind = read(bite, "kind");
-        if (biteKind !== "actual" && biteKind !== "noRealBite")
-            continue;
-        if (read(bite, "targetKey") !== targetKey)
-            throw new DoctorSubmissionContractError("lastRealBite 目标不匹配");
-        if (biteKind === "actual") {
-            const evidenceId = read(bite, "evidenceId");
-            const entry = typeof evidenceId === "string" ? store.entries.get(evidenceId) : undefined;
-            if (!entry || entry.kind !== "session" || !store.hasRead(entry.id))
-                throw new DoctorSubmissionContractError("actual bite 须引用已准入/已读的留存 session");
-        }
-        else {
-            const eligible = patient.evidence.map((entry) => entry.id).sort();
-            const ids = read(bite, "eligibleEvidenceIds");
-            if (Array.isArray(ids)) {
-                const claimed = ids.filter((id) => typeof id === "string").sort();
-                if (canonicalJson(claimed) !== canonicalJson(eligible))
-                    throw new DoctorSubmissionContractError("noRealBite 须证明完整的单案合格证据全集");
-                readCitations(eligible, "noRealBite");
-            }
-        }
+function validateDoctorOutput(value, patient, store) {
+  const output = validateDoctorSubmissionShape(value);
+  const lawfulTargets = /* @__PURE__ */ new Set(["case", ...patient.cost.invocations.sources]);
+  const assertTarget = (targetKey) => {
+    if (typeof targetKey === "string" && !lawfulTargets.has(targetKey)) throw new DoctorSubmissionContractError(`targetKey \u4E0D\u662F\u5408\u6CD5\u6848\u76EE\u6807\uFF1A${targetKey}`);
+  };
+  const readCitations = (ids, label) => {
+    if (!Array.isArray(ids)) return;
+    for (const id of ids) if (typeof id === "string" && (!store.entries.has(id) || !store.hasRead(id))) throw new DoctorSubmissionContractError(`${label} \u987B\u5F15\u7528\u5DF2\u51C6\u5165/\u5DF2\u8BFB\u8BC1\u636E\uFF1A${id}`);
+  };
+  if (read(output, "status") === "refused") {
+    const missingEvidence = read(output, "missingEvidence");
+    if (Array.isArray(missingEvidence)) for (const missing of missingEvidence) {
+      const targets = read(missing, "targetKeys");
+      if (Array.isArray(targets)) for (const target of targets) assertTarget(target);
     }
     return output;
+  }
+  const identity = read(output, "case");
+  const issueNumber = read(identity, "issueNumber");
+  const runsPath = read(identity, "runsPath");
+  if (issueNumber !== void 0 && issueNumber !== patient.identity.issueNumber || runsPath !== void 0 && runsPath !== patient.identity.runsPath) throw new DoctorSubmissionContractError("\u592A\u533B\u7F72\u4EA4\u5377 case \u987B\u7B49\u4E8E\u5DF2\u6FC0\u6D3B\u6848\u8EAB\u4EFD");
+  const findings = read(output, "findings");
+  if (!Array.isArray(findings)) return output;
+  for (const finding2 of findings) {
+    const targetKey = read(finding2, "targetKey");
+    readCitations(read(finding2, "evidenceIds"), "finding");
+    const assetEvidence = read(finding2, "assetEvidence");
+    if (!isRecord(assetEvidence)) {
+      assertTarget(targetKey);
+      continue;
+    }
+    const assetTargetKey = read(assetEvidence, "targetKey");
+    const assetTargetKind = read(assetEvidence, "targetKind");
+    const assetEvidenceId = read(assetEvidence, "evidenceId");
+    if (typeof assetTargetKey === "string" && assetTargetKey !== targetKey) throw new DoctorSubmissionContractError("\u7C7B\u578B\u5316\u8D44\u4EA7\u8BC1\u636E\u987B\u786E\u7ACB finding \u7684 targetKey");
+    if (typeof assetTargetKind === "string" && assetTargetKind !== read(finding2, "targetKind")) throw new DoctorSubmissionContractError("\u7C7B\u578B\u5316\u8D44\u4EA7\u8BC1\u636E\u987B\u786E\u7ACB finding \u7684 targetKind");
+    if (typeof assetEvidenceId === "string") readCitations([assetEvidenceId], "asset evidence");
+    const guardrails = read(finding2, "guardrails");
+    for (const key of ["reproducibleFailure", "owningSeamOrInvariant", "deletionOrSimplificationSuffices"]) readCitations(read(read(guardrails, key), "evidenceIds"), "guardrail");
+    const bite = read(finding2, "lastRealBite");
+    const biteKind = read(bite, "kind");
+    if (biteKind !== "actual" && biteKind !== "noRealBite") continue;
+    if (read(bite, "targetKey") !== targetKey) throw new DoctorSubmissionContractError("lastRealBite \u76EE\u6807\u4E0D\u5339\u914D");
+    if (biteKind === "actual") {
+      const evidenceId = read(bite, "evidenceId");
+      const entry = typeof evidenceId === "string" ? store.entries.get(evidenceId) : void 0;
+      if (!entry || entry.kind !== "session" || !store.hasRead(entry.id)) throw new DoctorSubmissionContractError("actual bite \u987B\u5F15\u7528\u5DF2\u51C6\u5165/\u5DF2\u8BFB\u7684\u7559\u5B58 session");
+    } else {
+      const eligible = patient.evidence.map((entry) => entry.id).sort();
+      const ids = read(bite, "eligibleEvidenceIds");
+      if (Array.isArray(ids)) {
+        const claimed = ids.filter((id) => typeof id === "string").sort();
+        if (canonicalJson(claimed) !== canonicalJson(eligible)) throw new DoctorSubmissionContractError("noRealBite \u987B\u8BC1\u660E\u5B8C\u6574\u7684\u5355\u6848\u5408\u683C\u8BC1\u636E\u5168\u96C6");
+        readCitations(eligible, "noRealBite");
+      }
+    }
+  }
+  return output;
 }
+export {
+  DOCTOR_ACCEPTED_AUDIT_NO_RECEIPT_TEXT,
+  DOCTOR_ACCEPTED_TEXT,
+  DOCTOR_EVIDENCE_TOOL_NAME,
+  DOCTOR_OUTPUT_TOOL_DESCRIPTION,
+  DOCTOR_OUTPUT_TOOL_NAME,
+  DOCTOR_TARGET_KINDS,
+  DoctorEvidenceStore,
+  DoctorSubmissionContractError,
+  doctorEvidenceReadSchema,
+  doctorOutputSchema,
+  doctorSubmissionSchema,
+  validateDoctorOutput,
+  validateDoctorSubmissionShape,
+  validateRecordedDoctorOutput
+};

package/dist/engine-detour-tool.js

@@ -1,94 +1,90 @@
-/**
- * Package-owned engine detour tool (#357 T2 / #378 / #380).
- * Registered by shared role-runtime when any role + engine activation signal is present.
- * Evidence-child legs install the same definition via customTools (no spawn in role modules).
- * Engine process failures stop through the host infrastructure-failure seam.
- * Caller AbortSignal cancellation propagates unchanged.
- */
 import { Type } from "typebox";
-import { ENGINE_DETOUR_TOOL_NAME, engineDetourFailureDiagnostic, engineNameFromEnv, isEngineDetourFailure, runEngineDetourOnce, } from "./engine-detour.js";
-const engineDetourArgsSchema = Type.Object({
+import {
+  ENGINE_DETOUR_TOOL_NAME,
+  engineDetourFailureDiagnostic,
+  engineNameFromEnv,
+  isEngineDetourFailure,
+  runEngineDetourOnce
+} from "./engine-detour.js";
+const engineDetourArgsSchema = Type.Object(
+  {
     argv: Type.Array(Type.String({ minLength: 1 }), {
-        minItems: 1,
-        description: "首项为 PATH 中的可执行文件，其余项为参数。",
-    }),
-}, { additionalProperties: false });
-/** Caller/upper-layer cancellation must propagate unchanged. */
+      minItems: 1,
+      description: "\u9996\u9879\u4E3A PATH \u4E2D\u7684\u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u5176\u4F59\u9879\u4E3A\u53C2\u6570\u3002"
+    })
+  },
+  { additionalProperties: false }
+);
 function isCallerCancellation(error, signal) {
-    if (signal?.aborted === true)
-        return true;
-    if (typeof error === "object" &&
-        error !== null &&
-        error.name === "AbortError") {
-        return true;
-    }
-    return false;
+  if (signal?.aborted === true) return true;
+  if (typeof error === "object" && error !== null && error.name === "AbortError") {
+    return true;
+  }
+  return false;
 }
-/**
- * Build one detour tool definition for a configured engine name.
- * `fail` owns host abort (parent) vs throw (evidence child) for tool misuse only.
- * Engine process failures (nonzero/empty/spawn) stop via `fail` with their cause.
- * Caller AbortSignal cancellation propagates unchanged.
- */
-export function createEngineDetourToolDefinition(input) {
-    const engineName = input.engineName;
-    return {
-        name: ENGINE_DETOUR_TOOL_NAME,
-        label: "劳务引擎",
-        description: `运行一次劳务引擎子进程（engine=${engineName}），stdout 返回本 session。`,
-        promptSnippet: "运行配置的劳务引擎一次并返回 stdout",
-        parameters: engineDetourArgsSchema,
-        async execute(toolCallId, params, signal, _onUpdate, ctx) {
-            const args = params;
-            const argv = Array.isArray(args.argv) ? args.argv : [];
-            if (argv.length === 0 || argv.some((part) => typeof part !== "string" || part.length === 0)) {
-                input.fail(new Error("劳务引擎 argv 须为非空字符串数组"), toolCallId, ctx);
-            }
-            let result;
-            try {
-                result = await runEngineDetourOnce({
-                    argv,
-                    cwd: ctx.cwd,
-                    ...(signal === undefined ? {} : { signal }),
-                });
-            }
-            catch (error) {
-                if (isCallerCancellation(error, signal))
-                    throw error;
-                const cause = error instanceof Error
-                    ? error
-                    : new Error(String(error).trim() || "劳务引擎 spawn 失败");
-                input.fail(cause, toolCallId, ctx);
-            }
-            if (isEngineDetourFailure(result)) {
-                input.fail(new Error(engineDetourFailureDiagnostic(result)), toolCallId, ctx);
-            }
-            return {
-                content: [{ type: "text", text: result.stdout }],
-                details: {
-                    tool: ENGINE_DETOUR_TOOL_NAME,
-                    code: result.code,
-                    stderr: result.stderr,
-                },
-            };
-        },
-    };
+function createEngineDetourToolDefinition(input) {
+  const engineName = input.engineName;
+  return {
+    name: ENGINE_DETOUR_TOOL_NAME,
+    label: "\u52B3\u52A1\u5F15\u64CE",
+    description: `\u8FD0\u884C\u4E00\u6B21\u52B3\u52A1\u5F15\u64CE\u5B50\u8FDB\u7A0B\uFF08engine=${engineName}\uFF09\uFF0Cstdout \u8FD4\u56DE\u672C session\u3002`,
+    promptSnippet: "\u8FD0\u884C\u914D\u7F6E\u7684\u52B3\u52A1\u5F15\u64CE\u4E00\u6B21\u5E76\u8FD4\u56DE stdout",
+    parameters: engineDetourArgsSchema,
+    async execute(toolCallId, params, signal, _onUpdate, ctx) {
+      const args = params;
+      const argv = Array.isArray(args.argv) ? args.argv : [];
+      if (argv.length === 0 || argv.some((part) => typeof part !== "string" || part.length === 0)) {
+        input.fail(
+          new Error("\u52B3\u52A1\u5F15\u64CE argv \u987B\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32\u6570\u7EC4"),
+          toolCallId,
+          ctx
+        );
+      }
+      let result;
+      try {
+        result = await runEngineDetourOnce({
+          argv,
+          cwd: ctx.cwd,
+          ...signal === void 0 ? {} : { signal }
+        });
+      } catch (error) {
+        if (isCallerCancellation(error, signal)) throw error;
+        const cause = error instanceof Error ? error : new Error(String(error).trim() || "\u52B3\u52A1\u5F15\u64CE spawn \u5931\u8D25");
+        input.fail(cause, toolCallId, ctx);
+      }
+      if (isEngineDetourFailure(result)) {
+        input.fail(
+          new Error(engineDetourFailureDiagnostic(result)),
+          toolCallId,
+          ctx
+        );
+      }
+      return {
+        content: [{ type: "text", text: result.stdout }],
+        details: {
+          tool: ENGINE_DETOUR_TOOL_NAME,
+          code: result.code,
+          stderr: result.stderr
+        }
+      };
+    }
+  };
 }
-/**
- * Register the engine-generic detour tool once for this process when any role has
- * an engine activation signal. Returns whether registration occurred.
- */
-export function registerEngineDetourTool(roleHost, hostActions) {
-    const engineName = engineNameFromEnv();
-    if (engineName === undefined) {
-        return false;
+function registerEngineDetourTool(roleHost, hostActions) {
+  const engineName = engineNameFromEnv();
+  if (engineName === void 0) {
+    return false;
+  }
+  const definition = createEngineDetourToolDefinition({
+    engineName,
+    fail(error, toolCallId, ctx) {
+      hostActions.failInfrastructure(error, ctx, toolCallId);
     }
-    const definition = createEngineDetourToolDefinition({
-        engineName,
-        fail(error, toolCallId, ctx) {
-            hostActions.failInfrastructure(error, ctx, toolCallId);
-        },
-    });
-    roleHost.registerTool(definition);
-    return true;
+  });
+  roleHost.registerTool(definition);
+  return true;
 }
+export {
+  createEngineDetourToolDefinition,
+  registerEngineDetourTool
+};