@akagilnc/pi-workflow-roles 0.1.5357 → 0.1.5368

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/public-cli/auto-resume.ts

@@ -210,7 +210,7 @@ function jsonSafeReplacer(): (key: string, value: unknown) => unknown {
  * + O_NOFOLLOW where the platform provides it (a planted symlink is never
  * followed) — mirrors settlement.ts's own hardened artifact writers.
  */
-async function writeHardenedArtifactFile(
+export async function writeHardenedArtifactFile(
   artifactsDir: string,
   namePrefix: string,
   payload: Record<string, unknown>,