@akagilnc/pi-workflow-roles 0.1.5357 → 0.1.5365

package/package.json

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

package/src/diarist-role.ts

@@ -18,38 +18,12 @@ export { validateRecordedDiaristOutput };
 /**
  * 起居郎交卷形状。
  * #901：交边界（sessions）；正文与不可解析原字节由机械投影。
+ * status 的合法词（completed | escalate）写在 description，结算认这些词。
+ * sessions / ticketSessions 是投影所读的边界：卷路径或端点读不出时走既有 reask，不中止本轮。
+ * 声明只留字段名和语义说明，不留类型、嵌套、长度、必填。
  */
-const diaristSessionsSchema = Type.Array(
-  Type.Object(
-    {
-      path: Type.Optional(Type.String({ description: "会话卷绝对或可读路径" })),
-      ranges: Type.Optional(
-        Type.Array(
-          Type.Object(
-            {
-              from: Type.Optional(
-                Type.Object(
-                  { id: Type.Optional(Type.String()), line: Type.Optional(Type.Unknown()) },
-                  { additionalProperties: true, description: "起点：原生 id 或本轮行号二选一" },
-                ),
-              ),
-              to: Type.Optional(
-                Type.Object(
-                  { id: Type.Optional(Type.String()), line: Type.Optional(Type.Unknown()) },
-                  { additionalProperties: true, description: "终点：原生 id 或本轮行号二选一" },
-                ),
-              ),
-            },
-            { additionalProperties: true, description: "一段对话区间" },
-          ),
-          { description: "本卷本轮各区间；至少一段" },
-        ),
-      ),
-    },
-    { additionalProperties: true, description: "一卷会话的边界" },
-  ),
-  { description: "对话边界；空列表＝本轮无对话可划。端点无法指名时走 reask，不中止。" },
-);
+const DIARIST_SESSIONS_DESCRIPTION =
+  "对话边界。每卷含 path（会话卷绝对或可读路径）与 ranges（本卷本轮各区间）。每段区间含 from / to；起点与终点各写 id（原生 id）或 line（本轮行号），二选一。空列表＝本轮无对话可划。端点无法指名时走 reask，不中止。" as const;
 
 export const diaristOutputSchema = withTerminatingOutputDeclarations(
   openToolObject(
@@ -63,24 +37,13 @@ export const diaristOutputSchema = withTerminatingOutputDeclarations(
             "本庭对象票号（正整数）或 null/省略＝真无票；下游走 typed 键；认不出用 status=escalate，不洗成无录。机械层不重判。",
         }),
       ),
-      reason: Type.Optional(
-        Type.String({
-          description: "status 为 escalate 时：认不出本庭对象的原因",
-        }),
-      ),
-      sessions: Type.Optional(diaristSessionsSchema),
-      ticketSessions: Type.Optional(
-        Type.Array(
-          Type.Object(
-            {
-              ticketNumber: Type.Unknown({ description: "本条边界所归票号（正整数）" }),
-              sessions: diaristSessionsSchema,
-            },
-            { additionalProperties: true },
-          ),
-          { description: "多票庭逐票对话边界；一次交卷各票各自分录。与单票 sessions 二选一。" },
-        ),
-      ),
+      reason: Type.Unknown({
+        description: "status 为 escalate 时：认不出本庭对象的原因",
+      }),
+      sessions: Type.Optional(Type.Unknown({ description: DIARIST_SESSIONS_DESCRIPTION })),
+      ticketSessions: Type.Unknown({
+        description: `多票庭逐票对话边界；每票含 ticketNumber（本条边界所归票号，正整数）与 sessions（${DIARIST_SESSIONS_DESCRIPTION}）。一次交卷各票各自分录。与单票 sessions 二选一。`,
+      }),
     }),
   ),
 );

package/src/doctor-contracts.ts

@@ -1,6 +1,6 @@
 import { Type } from "typebox";
 import { canonicalJson } from "./canonical-json.ts";
-import { openToolObjectFromUnion } from "./open-tool-schema.ts";
+import { openToolObject } from "./open-tool-schema.ts";
 import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.ts";
 
 export const DOCTOR_EVIDENCE_TOOL_NAME = "ak_doctor_evidence";
@@ -9,6 +9,11 @@ export const DOCTOR_AUDIT_TOOL_NAME = "ak_doctor_audit_decision";
 export const DOCTOR_OUTPUT_TOOL_DESCRIPTION = "提交唯一终局单案证词；completed 允许空 findings。";
 export const DOCTOR_TARGET_KINDS = ["law", "gate", "template", "station", "seat"] as const;
 export type DoctorTargetKind = typeof DOCTOR_TARGET_KINDS[number];
+const DOCTOR_DISPOSITIONS = ["keep", "thin", "delete"] as const;
+const DOCTOR_PRESCRIPTION_KINDS = ["retain", "delete", "simplify", "patch", "addMechanism"] as const;
+const biteActual = "actual" as const;
+const biteNone = "noRealBite" as const;
+const DOCTOR_BITE_KINDS = [biteActual, biteNone] as const;
 export type DoctorCaseIdentity = { issueNumber: number; runsPath: string };
 export type DoctorSessionCost =
   | { source: string; startedAt: string; endedAt: string; wallMilliseconds: number; completion: "accepted" }
@@ -24,12 +29,12 @@ export type DoctorCaseCost = {
 };
 export type DoctorGuardrailAnswer = { answer: boolean; evidenceIds: string[]; explanation: string };
 export type DoctorLastRealBite =
-  | { kind: "actual"; targetKey: string; evidenceId: string }
-  | { kind: "noRealBite"; targetKey: string; eligibleEvidenceIds: string[] };
+  | { kind: typeof biteActual; targetKey: string; evidenceId: string }
+  | { kind: typeof biteNone; targetKey: string; eligibleEvidenceIds: string[] };
 type DoctorFindingBody = {
-  evidenceIds: string[]; disposition: "keep" | "thin" | "delete";
+  evidenceIds: string[]; disposition: (typeof DOCTOR_DISPOSITIONS)[number];
   guardrails: { reproducibleFailure: DoctorGuardrailAnswer; owningSeamOrInvariant: DoctorGuardrailAnswer; deletionOrSimplificationSuffices: DoctorGuardrailAnswer };
-  prescription: { kind: "retain" | "delete" | "simplify" | "patch" | "addMechanism"; recommendation: string; necessityExplanation?: string };
+  prescription: { kind: (typeof DOCTOR_PRESCRIPTION_KINDS)[number]; recommendation: string; necessityExplanation?: string };
   lastRealBite: DoctorLastRealBite;
 };
 type DoctorAssetKind = DoctorTargetKind;
@@ -45,55 +50,39 @@ export type DoctorOutput = DoctorSubmission;
 export type DoctorEvidenceEntry = { id: string; kind: "session" | "stderr"; byteLength: number; contentLength: number; sha256: string; content: string };
 export type DoctorCase = { version: 1; identity: DoctorCaseIdentity; evidence: DoctorEvidenceEntry[]; cost: DoctorCaseCost };
 
-// #836 r16 class 1: case/finding/assetEvidence/guardrails/prescription/
-// lastRealBite/missingEvidence are LLM/human-read narrative content — Judge/
-// 台院 read the original volume, no code branches on their length or nested
-// presence (src/doctor-contracts.ts:136-138 passes the submission through
-// unprojected). Field/type/description/Literal value stay; provider
-// required/minLength/minItems/minimum/nested additionalProperties:false is deleted.
-const nonblank = Type.Optional(Type.String());
-const evidenceIds = Type.Optional(Type.Array(Type.String()));
-const guardrail = Type.Object({ answer: Type.Optional(Type.Boolean()), evidenceIds, explanation: nonblank }, { additionalProperties: true });
-const lastRealBite = Type.Union([
-  Type.Object({ kind: Type.Optional(Type.Literal("actual")), targetKey: nonblank, evidenceId: nonblank }, { additionalProperties: true }),
-  Type.Object({ kind: Type.Optional(Type.Literal("noRealBite")), targetKey: nonblank, eligibleEvidenceIds: evidenceIds }, { additionalProperties: true }),
-]);
-const assetKinds = DOCTOR_TARGET_KINDS;
-const findingBody = {
-  evidenceIds, disposition: Type.Optional(Type.Union([Type.Literal("keep"), Type.Literal("thin"), Type.Literal("delete")])),
-  guardrails: Type.Optional(Type.Object({ reproducibleFailure: guardrail, owningSeamOrInvariant: guardrail, deletionOrSimplificationSuffices: guardrail }, { additionalProperties: true })),
-  prescription: Type.Optional(Type.Object({ kind: Type.Optional(Type.Union([Type.Literal("retain"), Type.Literal("delete"), Type.Literal("simplify"), Type.Literal("patch"), Type.Literal("addMechanism")])), recommendation: nonblank, necessityExplanation: nonblank }, { additionalProperties: true })), lastRealBite: Type.Optional(lastRealBite),
-};
-const finding = Type.Union([
-  Type.Object({ targetKey: nonblank, observation: nonblank, evidenceIds }, { additionalProperties: true }),
-  Type.Object({ targetKey: nonblank, targetKind: Type.Optional(Type.Union(assetKinds.map((kind) => Type.Literal(kind)))), assetEvidence: Type.Optional(Type.Object({ targetKey: nonblank, targetKind: Type.Optional(Type.Union(assetKinds.map((kind) => Type.Literal(kind)))), evidenceId: nonblank }, { additionalProperties: true })), ...findingBody }, { additionalProperties: true }),
-]);
-const caseIdentity = Type.Object({ issueNumber: Type.Optional(Type.Integer()), runsPath: nonblank }, { additionalProperties: true });
-// #836 (ADR 0003 Amendment): status kept open like countersignStatus
-// (src/countersign-role.ts) — one shared description across both variants
-// so openToolObjectFromUnion's identical-declaration collapse drops none of it.
+// status 的合法词写在 description。交卷原样入账（validateDoctorSubmissionShape），
+// 本文件不按 completed | refused 改道。case / findings / reason / missingEvidence
+// 同样不按长度或嵌套改道，台院读原卷。声明只留字段名和语义说明，不留类型、嵌套、
+// 枚举、长度、必填。
+// The evidence-read action tool below keeps its own constraints — code reads
+// evidenceId/offset/limit to look up and slice (DoctorEvidenceStore.read), which
+// is a live-target binding, not a submission shape gate (ADR 0037).
 const DOCTOR_STATUS_DESCRIPTION =
   "completed | refused。completed 允许空 findings；refused 仅当证据不足以支撑如实案证词" as const;
-const doctorSubmissionVariants = Type.Union([
-  Type.Object({
-    status: Type.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
-    case: Type.Unsafe({ ...caseIdentity, description: "留存太医署案身份" }),
-    findings: Type.Array(finding, { description: "可空或仅含非处方案观察；缺可复用资产或 bounded-bite 证据只排除对应资产处方" }),
-  }, { additionalProperties: false, description: "单案证词，不要求任何处方或可复用 finding" }),
-  Type.Object({
-    status: Type.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
-    reason: Type.String({ description: "证据不足以支撑如实证词的原因" }),
-    missingEvidence: Type.Array(Type.Object({ need: nonblank, targetKeys: evidenceIds }, { additionalProperties: true }), { description: "如实证词所需而尚缺的证据" }),
-  }, { additionalProperties: false, description: "证据不足以支撑如实案证词" }),
-]);
+const doctorSubmissionObject = Type.Object({
+  status: Type.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
+  case: Type.Unknown({
+    description:
+      "留存太医署案身份，原样留存（如 issueNumber、runsPath）。机械层另按绑定 run 投影案身份，不在本字段重判。",
+  }),
+  findings: Type.Unknown({
+    description:
+      `逐条资产观察与处方，原样留存。一条可含 targetKey、targetKind（${DOCTOR_TARGET_KINDS.join(" | ")}）、observation、evidenceIds、disposition（${DOCTOR_DISPOSITIONS.join(" | ")}）、assetEvidence（targetKey、targetKind、evidenceId）、guardrails（reproducibleFailure、owningSeamOrInvariant、deletionOrSimplificationSuffices，各项可含 answer、evidenceIds、explanation）、prescription（kind 为 ${DOCTOR_PRESCRIPTION_KINDS.join(" | ")}，另可写 recommendation、necessityExplanation）、lastRealBite（kind 为 ${DOCTOR_BITE_KINDS.join(" | ")}，另可写 targetKey、evidenceId、eligibleEvidenceIds）。不要求任何处方或可复用 finding；缺可复用资产或 bounded-bite 证据只排除对应资产处方。机器不核验。`,
+  }),
+  reason: Type.Unknown({
+    description: "证据不足以支撑如实证词的原因；仅 refused 时用。",
+  }),
+  missingEvidence: Type.Unknown({
+    description: "如实证词所需而尚缺的证据，原样留存（如每项 need、targetKeys）。",
+  }),
+});
 export const doctorSubmissionSchema = withTerminatingOutputDeclarations(
-  openToolObjectFromUnion(doctorSubmissionVariants),
+  openToolObject(doctorSubmissionObject),
 );
 // #836 r16 class 3: action tool — code reads evidenceId to look up the Map entry
-// and offset/limit to slice + accumulate coverage (src/doctor-contracts.ts:97-128,
-// src/doctor-role.ts:38); those constraints stay. Root additionalProperties:false
-// is deleted — no reader consumes extra fields, so a closed object only rejects
-// the role for saying more (src/doctor-role.ts execute reads named params only).
+// and offset/limit to slice + accumulate coverage (DoctorEvidenceStore.read);
+// those constraints stay. Root additionalProperties:false is deleted — no reader
+// consumes extra fields, so a closed object only rejects the role for saying more.
 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, description: "返回字节数（无上限）" })) }, { additionalProperties: true });
 export class DoctorSubmissionContractError extends Error { override readonly name = "DoctorSubmissionContractError"; }
 function isRecord(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); }

package/src/gleaner-left-role.ts

@@ -17,23 +17,22 @@ export { validateRecordedGleanerLeftOutput };
 
 // #836 r16 class 1: pointer/statement are LLM/human-read narrative content — no
 // code branches on their presence.
-/** 左拾遗弹章交卷形状。 */
+// #1134: `status` alone is the trajectory field (src/gleaner-left-contracts.ts:38
+// recognizes completed to settle); its word rides the description. findings is
+// narrative content declared name + semantic description only — the array type
+// and the nested pointer/statement object shape are deleted, because the package
+// declaration IS the host's pre-dispatch validator. An empty findings list stays
+// a lawful completion; an omitted one is now expressible too.
 export const gleanerLeftOutputSchema = withTerminatingOutputDeclarations(
   openToolObject(
     Type.Object({
       status: Type.Unknown({
         description: "completed",
       }),
-      findings: Type.Array(
-        Type.Object(
-          {
-            pointer: Type.Optional(Type.String({ description: "文件/行指针" })),
-            statement: Type.Optional(Type.String({ description: "疑点陈述" })),
-          },
-          { additionalProperties: true, description: "一条弹章" },
-        ),
-        { description: "弹章列表；空列表合法完局" },
-      ),
+      findings: Type.Unknown({
+        description:
+          "弹章列表；每条可含 pointer（文件/行指针）与 statement（疑点陈述），原样留存。空列表合法完局；机器不判弹章是否成立。",
+      }),
     }),
   ),
 );

package/src/merger-contracts.ts

@@ -1,6 +1,6 @@
 import { Type, type Static } from "typebox";
 import { exactUtf8 } from "./exact-utf8.ts";
-import { openToolObjectFromUnion } from "./open-tool-schema.ts";
+import { openToolObject } from "./open-tool-schema.ts";
 import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.ts";
 
 const materialSchema = Type.Object({ bytesBase64: Type.String(), sha256: Type.String() }, { additionalProperties: false });
@@ -14,18 +14,25 @@ export const mergerInputSchema = Type.Object({
   resolutionScope: Type.Array(Type.String(), { description: "材料：解析范围提示；可空" }),
   authorizedChecks: Type.Array(checkSchema),
 }, { additionalProperties: false });
-// #836 r16 class 1: attemptId/report/diagnosis are LLM/human-read narrative
-// content (candidate stored as submitted) — no code branches on their length.
-// mergerInputSchema (host-authored material, not role output) is out of scope.
-// #836 (ADR 0003 Amendment): status kept open like countersignStatus
-// (src/countersign-role.ts) — one shared description across both variants
-// so openToolObjectFromUnion's identical-declaration collapse drops none of it.
+// #836 r16 class 1: attemptId/report/diagnosis/mergeCommitId are LLM/human-read
+// narrative content (candidate stored as submitted) — no code branches on their
+// length. mergerInputSchema (host-authored material, not role output) is out of scope.
+// #1134: `status` alone is the trajectory field (src/packaged-role-registry.ts:327-328
+// receiptCommitWhen picks the commit read off a completed receipt); its words ride
+// the description. Every other output field is declared name + semantic description
+// only — string type, required and the two-variant union are deleted, because the
+// package declaration IS the host's pre-dispatch validator.
 const MERGER_STATUS_DESCRIPTION = "completed | escalate" as const;
-const mergerOutputVariants = Type.Union([
-  Type.Object({ status: Type.Unknown({ description: MERGER_STATUS_DESCRIPTION }), attemptId: Type.String({ description: "已受理合并 attempt 身份" }), report: Type.String({ description: "如实结果报告" }), mergeCommitId: Type.String({ description: "完成合并 commit object ID" }) }, { additionalProperties: false }),
-  Type.Object({ status: Type.Unknown({ description: MERGER_STATUS_DESCRIPTION }), attemptId: Type.String({ description: "已受理合并 attempt 身份" }), diagnosis: Type.String({ description: "合并无法或不应由本席完成的原因（含无进行中合并、无活可干、需新的产品/权力决定）" }), report: Type.String({ description: "如实结果报告" }) }, { additionalProperties: false }),
-]);
-export const mergerOutputSchema = withTerminatingOutputDeclarations(openToolObjectFromUnion(mergerOutputVariants));
+const mergerOutputObject = Type.Object({
+  status: Type.Unknown({ description: MERGER_STATUS_DESCRIPTION }),
+  attemptId: Type.Unknown({ description: "已受理合并 attempt 身份" }),
+  report: Type.Unknown({ description: "如实结果报告" }),
+  mergeCommitId: Type.Unknown({ description: "完成合并 commit object ID" }),
+  diagnosis: Type.Unknown({
+    description: "合并无法或不应由本席完成的原因（含无进行中合并、无活可干、需新的产品/权力决定）",
+  }),
+});
+export const mergerOutputSchema = withTerminatingOutputDeclarations(openToolObject(mergerOutputObject));
 
 export type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer U)[] ? readonly DeepReadonly<U>[] : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;
 export type MergerMaterial = DeepReadonly<Static<typeof materialSchema>>;

package/src/open-tool-schema.ts

@@ -1,41 +1,17 @@
 import { Type, type TSchema } from "typebox";
 
-type UnionSchema = TSchema & { anyOf: Array<TSchema & { properties?: Record<string, TSchema> }> };
-
 function described(name: string, schema: TSchema): TSchema {
   if (typeof (schema as { description?: unknown }).description === "string") return schema;
   throw new Error(`Tool field ${name} has no semantic description at its schema owner`);
 }
 
-function declarationIdentity(schema: TSchema): string {
-  const { description: _description, ...semantic } = schema as TSchema & { description?: string };
-  return JSON.stringify(semantic);
-}
-
-/** Collapse transport variants into one provider-compatible open object. Non-three-state tools stay zero-required. */
-export function openToolObjectFromUnion(schema: UnionSchema): TSchema {
-  const declarations = new Map<string, TSchema[]>();
-  for (const variant of schema.anyOf) {
-    for (const [name, declaration] of Object.entries(variant.properties ?? {})) {
-      const entries = declarations.get(name) ?? [];
-      const identity = declarationIdentity(declaration);
-      if (!entries.some((entry) => declarationIdentity(entry) === identity)) entries.push(declaration);
-      declarations.set(name, entries);
-    }
-  }
-  const properties = Object.fromEntries([...declarations].map(([name, entries]) => {
-    const descriptions = [...new Set(entries.map((entry) => (entry as { description?: unknown }).description).filter((value): value is string => typeof value === "string"))].join(" ");
-    const declaration = entries.length === 1
-      ? entries[0]!
-      : Type.Union(entries, descriptions === "" ? {} : { description: descriptions });
-    return [name, Type.Optional(described(name, declaration))];
-  }));
-  const object = Type.Object(properties, { additionalProperties: true });
-  (object as unknown as { required: string[] }).required = [];
-  return object;
-}
-
-/** Open a pre-existing object transport schema. Every field stays optional. */
+/**
+ * One open tool object per submission tool. Every field stays optional, the root
+ * accepts extra keys, and each field declaration carries a semantic description
+ * with no type/nesting/enum/length constraint (#1134): the package declaration
+ * is what the host validates before dispatch, so anything narrower than a name
+ * plus its meaning is a rejection rule no owner approved.
+ */
 export function openToolObject(
   schema: TSchema & { properties: Record<string, TSchema> },
 ): TSchema {
@@ -48,4 +24,4 @@ export function openToolObject(
   );
   (object as unknown as { required: string[] }).required = [];
   return object;
-}
+}

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

@@ -1,68 +1,65 @@
-import { Type, type Static } from "typebox";
-import { openToolObjectFromUnion } from "../open-tool-schema.ts";
+import { Type } from "typebox";
+import { openToolObject } from "../open-tool-schema.ts";
 import { withTerminatingOutputDeclarations } from "./terminating-infrastructure.ts";
 
 export const FIXER_OUTPUT_TOOL_NAME = "ak_fixer_output";
 
-// #836 r16 class 1: these are LLM/human-read narrative content — the candidate
-// row lands on the ledger as submitted (src/submission-ledger.ts:351-390) and no
-// code branches on its shape. Field/type/description/Literal value stay; provider
-// required/minLength/minItems is deleted. `reason` alone keeps minLength: the
-// worker gate reads `reason.trim().length > 0` to pick typed-reminder-bounce vs
-// accept (src/worker-submission-gates.ts:159-163,297-302).
-const transportString = Type.String();
-const authorityBlockerSchema = Type.Object({ cause: Type.Optional(Type.Literal("authority_violation")), evidence: Type.Optional(transportString) });
-const prerequisiteBlockerSchema = Type.Object({ cause: Type.Optional(Type.Literal("prerequisite_unmet")), prerequisiteId: Type.Optional(transportString), evidence: Type.Optional(transportString) });
-const blockerSchema = Type.Union([authorityBlockerSchema, prerequisiteBlockerSchema]);
-const exceptionSchema = Type.Object({ where: Type.Optional(transportString), reason: Type.Optional(transportString) });
-/** ⑥ test evidence slip — require submit when diff has test changes; machine does not check existence/completeness/coverage. */
-const testEvidenceSchema = Type.Object({
-  contract: Type.Optional(Type.String({ description: "测试改动所证明的契约" })),
-  minimumNecessaryCost: Type.Optional(Type.String({ description: "测试改动的一行最小必要成本" })),
-  measuredDuration: Type.Optional(Type.String({ description: "聚焦验证实测时长" })),
-}, { description: "测试证据条；diff 含测试改动时提交；机器不核验。" });
-const completedClassResultSchema = Type.Object({
-  name: Type.Optional(transportString),
-  disposition: Type.Optional(Type.Literal("completed")),
-  searchScope: Type.Optional(transportString),
-  exceptions: Type.Optional(Type.Array(exceptionSchema)),
-  commitSha: Type.Optional(transportString),
-});
-const refusedClassResultSchema = Type.Object({
-  name: Type.Optional(transportString),
-  disposition: Type.Optional(Type.Literal("refused")),
-  remainingScope: Type.Optional(transportString),
-  blocker: Type.Optional(blockerSchema),
-});
-const classResultSchema = Type.Union([completedClassResultSchema, refusedClassResultSchema]);
-const completedClassResultsSchema = Type.Array(completedClassResultSchema);
-
 /** Owner 2026-09-28: partially_completed only when a lawful refusal exists; never otherwise (ADR 0015). */
 export const PARTIALLY_COMPLETED_DEFINITION =
   "partially_completed 只能在有合法拒绝项（完成项与合法拒绝项并存）时用，别的情况不准用。" as const;
-// #836 (ADR 0003 Amendment): status kept open like countersignStatus
-// (src/countersign-role.ts) — one shared description across every variant
-// so openToolObjectFromUnion's identical-declaration collapse drops none of it.
+// status 的合法词写在 description。completed / partially_completed 进入提交闸；
+// unfinished 且未见理由说明时，运行时同 run 催全（ADR 0050），理由在不在不按 JSON 类型判。
+// 其余字段入账原样留存。声明只留字段名和语义说明，不留类型、嵌套、枚举、长度、必填。
 const FIXER_STATUS_DESCRIPTION =
   `planned | completed | refused | unfinished | partially_completed。unfinished 缺前置或违宪约束致本局未完成时可用，缺待决 owner 决定或答复属缺前置。${PARTIALLY_COMPLETED_DEFINITION}` as const;
-const fixerOutputVariants = Type.Union([
-  Type.Object({ status: Type.Unknown({ description: FIXER_STATUS_DESCRIPTION }), report: Type.String({ description: "如实结果报告" }) }),
-  Type.Object({ status: Type.Unknown({ description: FIXER_STATUS_DESCRIPTION }), report: Type.String({ description: "如实结果报告" }), remainingScope: Type.String({ description: "依法不能完成的工作范围" }), blocker: Type.Unsafe({ ...blockerSchema, description: "合法阻断完成的 blocker" }) }),
-  Type.Object({ status: Type.Unknown({ description: FIXER_STATUS_DESCRIPTION }), report: Type.String({ description: "如实结果报告" }), remainingScope: Type.String({ description: "本局后剩余工作" }), reason: Type.Optional(Type.String({ minLength: 1, description: "阻断原因：缺前置或违宪约束。缺待决 owner 决定或答复属缺前置。" })), classResults: Type.Optional(Type.Unsafe({ ...completedClassResultsSchema, description: "本局已完成的 class 结算" })), testEvidence: Type.Optional(testEvidenceSchema) }),
-  Type.Object({ status: Type.Unknown({ description: FIXER_STATUS_DESCRIPTION }), report: Type.String({ description: "如实结果报告" }), classResults: Type.Array(classResultSchema, { description: "已完成的 class 结算" }), testEvidence: Type.Optional(testEvidenceSchema) }),
-  Type.Object({ status: Type.Unknown({ description: FIXER_STATUS_DESCRIPTION }), report: Type.String({ description: "如实结果报告" }), classResults: Type.Array(classResultSchema, { description: "各类拒绝结算" }) }),
-  Type.Object({ status: Type.Unknown({ description: FIXER_STATUS_DESCRIPTION }), report: Type.String({ description: "如实结果报告" }), classResults: Type.Array(classResultSchema, { description: "各类完成或拒绝结算" }), testEvidence: Type.Optional(testEvidenceSchema) }),
-]);
+
+const fixerOutputObject = Type.Object({
+  status: Type.Unknown({ description: FIXER_STATUS_DESCRIPTION }),
+  report: Type.Unknown({ description: "如实结果报告" }),
+  remainingScope: Type.Unknown({
+    description: "本局后剩余工作；依法不能完成的范围也写此处。",
+  }),
+  blocker: Type.Unknown({
+    description:
+      "合法阻断完成的 blocker，原样留存。可写 cause（authority_violation 或 prerequisite_unmet）、evidence；prerequisite_unmet 还可写 prerequisiteId。",
+  }),
+  reason: Type.Unknown({
+    description: "阻断原因：缺前置或违宪约束。缺待决 owner 决定或答复属缺前置。",
+  }),
+  classResults: Type.Unknown({
+    description:
+      "各类 class 结算，原样留存。完成项的 disposition 为 completed，可写 name、searchScope、exceptions（where、reason）、commitSha。拒绝项的 disposition 为 refused，可写 name、remainingScope、blocker。",
+  }),
+  testEvidence: Type.Unknown({
+    description:
+      "测试证据条；diff 含测试改动时提交；机器不核验。可写 contract（测试改动所证明的契约）、minimumNecessaryCost（测试改动的一行最小必要成本）、measuredDuration（聚焦验证实测时长）。",
+  }),
+});
+
 export const fixerOutputSchema = withTerminatingOutputDeclarations(
-  openToolObjectFromUnion(fixerOutputVariants),
+  openToolObject(fixerOutputObject),
 );
 
-export type FixerBlocker = Static<typeof blockerSchema>;
-export type FixerClassResult = Static<typeof classResultSchema>;
-export type FixerTestEvidence = Static<typeof testEvidenceSchema>;
-export type FixerOutput = Static<typeof fixerOutputVariants>;
+export type FixerBlocker = Readonly<Record<string, unknown>>;
+export type FixerClassResult = Readonly<Record<string, unknown>>;
+export type FixerTestEvidence = Readonly<Record<string, unknown>>;
+/**
+ * One shared open receipt shape (#1134): every field is optional and carries no
+ * type constraint, matching what `openToolObject` hands the host. The union of
+ * per-status variants is gone — the declaration no longer discriminates, and the
+ * trajectory word is read off `status` at runtime, not off the schema.
+ */
+export type FixerOutput = {
+  readonly status?: unknown;
+  readonly report?: unknown;
+  readonly remainingScope?: unknown;
+  readonly blocker?: unknown;
+  readonly reason?: unknown;
+  readonly classResults?: unknown;
+  readonly testEvidence?: unknown;
+};
 export type FixerPhase = "plan" | "apply";
 
 export function validateFixerOutput(value: unknown, _phase?: FixerPhase): FixerOutput {
   return value as FixerOutput;
-}
+}

package/src/reviewer-role.ts

@@ -1,6 +1,6 @@
 import type { RoleHost, HostContext, HostToolResult } from "./host-contracts.ts";
 import { Type } from "typebox";
-import { openToolObjectFromUnion } from "./open-tool-schema.ts";
+import { openToolObject } from "./open-tool-schema.ts";
 import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.ts";
 
 import { REVIEWER_OUTPUT_TOOL_NAME, type ReviewerIntent } from "./package-contracts/reviewer-output.ts";
@@ -17,43 +17,24 @@ export type ReviewerAdmittedInputs = Readonly<{
   ticketNumber?: number;
 }>;
 
-const reviewerAmendmentsSchema = Type.Object({
-  completeness: Type.Optional(Type.String({
-    description:
-      "completeness lens 完整报告：candidates、逐条处置与 verdict；非仅 verdict 一行。hard-stop／usage error 为 refused 时，若已产出报告仍照录于此",
-  })),
-  correctness: Type.Optional(Type.String({
-    description:
-      "correctness lens 完整报告：candidates、逐条处置与 verdict；非仅 verdict 一行。hard-stop／usage error 为 refused 时，若已产出报告仍照录于此",
-  })),
-}, {
-  additionalProperties: true,
-  description:
-    "已运行 lens 的 amendments 承载 candidates、逐条处置与 verdict 的完整报告（非仅 verdict 行）；显式单轴时另一轴可省略。hard-stop／usage error 为 refused 时，已产出报告仍照录对应 lens 字段。",
-});
-// #836 r16 class 1: diagnostic is LLM/human-read narrative content — no code
-// branches on its length (src/reviewer-role.ts consumer: reviewer content is
-// returned as submitted, ADR 0057).
-// #836 (ADR 0003 Amendment): status kept open like countersignStatus
-// (src/countersign-role.ts) — one shared description across both variants
-// so openToolObjectFromUnion's identical-declaration collapse drops none of it.
-// #917 §6: both normal lens verdicts → completed; hard-stop/usage error → refused
-// (report already produced still lands in selected-lens amendments).
+const REVIEWER_AMENDMENTS_DESCRIPTION =
+  "已运行 lens 的 amendments 承载 candidates、逐条处置与 verdict 的完整报告（非仅 verdict 行）；显式单轴时另一轴可省略（completeness / correctness）。hard-stop／usage error 为 refused 时，已产出报告仍照录对应 lens 字段。" as const;
+// #1134: `status` alone is the trajectory field (#917 §6 two normal lens verdicts →
+// completed; hard-stop / usage error → refused); its words ride the description.
+// amendments/diagnostic are LLM/human-read narrative content returned as
+// submitted — declaration keeps name + semantic description only, no nested
+// object shape, no string type, no required constraint.
 const REVIEWER_STATUS_DESCRIPTION =
   "completed | refused。两种正常 lens verdict（completeness / correctness）均 completed；hard-stop 与 usage error 为 refused（已产出报告仍照录进所选 lens amendments）。" as const;
-const reviewerOutputVariants = Type.Union([
-  Type.Object({
-    status: Type.Unknown({ description: REVIEWER_STATUS_DESCRIPTION }),
-    amendments: Type.Optional(reviewerAmendmentsSchema),
-  }, { additionalProperties: false }),
-  Type.Object({
-    status: Type.Unknown({ description: REVIEWER_STATUS_DESCRIPTION }),
-    diagnostic: Type.String({ description: "拒绝诊断说明；hard-stop／usage error 原因进此字段，已产出报告另照录 amendments" }),
-    amendments: Type.Optional(reviewerAmendmentsSchema),
-  }, { additionalProperties: false }),
-]);
+const reviewerOutputObject = Type.Object({
+  status: Type.Unknown({ description: REVIEWER_STATUS_DESCRIPTION }),
+  amendments: Type.Unknown({ description: REVIEWER_AMENDMENTS_DESCRIPTION }),
+  diagnostic: Type.Unknown({
+    description: "拒绝诊断说明；hard-stop／usage error 原因进此字段，已产出报告另照录 amendments",
+  }),
+});
 export const reviewerOutputSchema = withTerminatingOutputDeclarations(
-  openToolObjectFromUnion(reviewerOutputVariants),
+  openToolObject(reviewerOutputObject),
 );
 export type ReviewerRoleDependencies = {
   loadSoul(): Promise<string>;

package/src/secretariat-role.ts

@@ -12,7 +12,17 @@ import { SECRETARIAT_OUTPUT_TOOL_NAME, type SecretariatVerdict } from "./secreta
 export { SECRETARIAT_OUTPUT_TOOL_NAME } from "./secretariat-contracts.ts";
 export type { SecretariatVerdict };
 
-/** 中书省终局回执形状。 */
+/**
+ * 中书省终局回执形状。
+ * #1134: `secretariatStatus` alone is the trajectory field
+ * (src/packaged-role-registry.ts:406 receiptStatusKey; the public settlement reads
+ * converged | escalate to route); its words ride the description. note/evidence/
+ * decisionGate are declared name + semantic description only — the string type, the
+ * number type, the nested question/options object shape and the required constraint
+ * are deleted, because the package declaration IS the host's pre-dispatch validator.
+ * (ticketNumber keeps its own declaration: it is the declared seat identity the
+ * activation flag and settlement read, not narrative content.)
+ */
 export const secretariatVerdictSchema = withTerminatingOutputDeclarations(
   Type.Object(
     {
@@ -20,19 +30,13 @@ export const secretariatVerdictSchema = withTerminatingOutputDeclarations(
         description: "converged | escalate",
       }),
       ticketNumber: Type.Optional(
-        Type.Number({ description: "本票号；署时指向最终正文所在票" }),
+        Type.Unknown({ description: "本票号；署时指向最终正文所在票" }),
       ),
-      note: Type.Optional(Type.String({ description: "附注" })),
+      note: Type.Unknown({ description: "附注" }),
       evidence: Type.Optional(Type.Unknown({ description: "留存证据" })),
-      decisionGate: Type.Optional(
-        Type.Object(
-          {
-            question: Type.Optional(Type.String()),
-            options: Type.Optional(Type.Array(Type.String())),
-          },
-          { additionalProperties: true, description: "需陛下处置的问题与选项" },
-        ),
-      ),
+      decisionGate: Type.Unknown({
+        description: "需陛下处置的问题与选项；可写 question 与 options，原样留存。",
+      }),
     },
     { additionalProperties: true },
   ),