@akagilnc/pi-workflow-roles 0.1.5375 → 0.1.5406

package/dist/public-cli/settlement.js

@@ -27,7 +27,7 @@ import { REVIEWER_OUTPUT_TOOL_NAME, } from "../package-contracts/reviewer-output
 import { packagedAuditToolName, packagedDurableOfficerEntry, packagedRoleAcceptedOutputTool, packagedRoleMetadata, packagedSkipsGateOnInfrastructureStage, } from "../packaged-role-registry.js";
 import { SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY, SECRETARIAT_GATE_OFFICER_ENTRY_TYPE, } from "../secretariat-contracts.js";
 import { classifyPackagedRoleTerminalResult, findLatestDurablePackagedRoleTerminal, hasNavigatorInfrastructureFailureBase, isAcceptedPackagedRoleTerminalResult, NAVIGATOR_ROUTE_PLAYBOOK_FAILURE_ENTRY, } from "../navigator-invocation-identity.js";
-import { NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_TURN_LIMIT, noReceiptLifecycleFacts, parseNoReceiptLifecycleFacts, } from "../receipt-delivery-policy.js";
+import { NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, noReceiptLifecycleFacts, parseNoReceiptLifecycleFacts, priorReceiptContinuation, receiptAttemptPointer, } from "../receipt-delivery-policy.js";
 import { roleRunArtifactsDirectory } from "../role-run-placement.js";
 import { rewriteRunDirectoryPathValue } from "../role-run-relocation.js";
 import { listSeamOwnedUniqueErrorFacePaths, RUN_TERMINAL_ARTIFACT_FILES, RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS, } from "../run-terminal-artifacts.js";
@@ -139,13 +139,100 @@ export async function attachRecordedSubmissions(admitted, terminal, scope) {
  * Does not invent an output failure for an empty ledger.
  * #953: empty public terminal face — clear every reader-adoptable prior face.
  */
-export async function settleHostEndedNoReceipt(admitted, authority, scope) {
+/**
+ * Lifecycle fact the in-process runtime already wrote for this run and attempt.
+ * Absent, malformed, or a previous attempt's bytes are not a count.
+ */
+function lifecycleFactsFromEntry(entry) {
+    const customType = entry.customType ?? entry.message?.customType;
+    if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE)
+        return undefined;
+    return entry.data ?? entry.message?.details;
+}
+async function readCurrentAttemptNoReceiptFacts(admitted, authority, scope) {
+    const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+    const entries = await readBoundSessionEntries(sessionFile).catch(() => undefined);
+    if (entries === undefined)
+        return undefined;
+    const scopeId = scope?.invocationScopeId?.trim() ?? "";
+    if (scopeId.length > 0) {
+        const pointer = receiptAttemptPointer(admitted.runDirectory, scopeId);
+        let selected;
+        for (const entry of entries) {
+            const raw = lifecycleFactsFromEntry(entry);
+            if (raw === undefined)
+                continue;
+            try {
+                const facts = parseNoReceiptLifecycleFacts(raw);
+                if (facts.runPointer !== admitted.runDirectory)
+                    continue;
+                if (facts.attemptPointer !== pointer)
+                    continue;
+                if (selected === undefined || facts.deliveryTurns >= selected.deliveryTurns) {
+                    selected = facts;
+                }
+            }
+            catch {
+                // A malformed historical entry is not this call's count.
+            }
+        }
+        return selected;
+    }
+    let attemptStart = 0;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") {
+            attemptStart = index;
+            break;
+        }
+    }
+    const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => lifecycleFactsFromEntry(entry) !== undefined);
+    const raw = lifecycleEntry === undefined ? undefined : lifecycleFactsFromEntry(lifecycleEntry);
+    if (raw === undefined)
+        return undefined;
+    let facts;
+    try {
+        facts = parseNoReceiptLifecycleFacts(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (facts.runPointer !== admitted.runDirectory)
+        return undefined;
+    if (facts.attemptPointer !== receiptAttemptPointer(admitted.runDirectory))
+        return undefined;
+    return facts;
+}
+export async function settleHostEndedNoReceipt(admitted, authority, scope, 
+/**
+ * #1132: delivery requests this run actually issued. Zero stays zero when
+ * nothing was sent and this attempt has no lifecycle fact. A fact already
+ * written for this run and attempt supplies the count when it is larger.
+ * The budget is never the count, and another loop's resumes are not催交.
+ */
+issuedDeliveryRequests = 0) {
+    const scopeId = scope?.invocationScopeId?.trim() ?? "";
+    const persisted = scopeId.length > 0
+        ? undefined
+        : await readCurrentAttemptNoReceiptFacts(admitted, authority, scope);
+    let terminalToolCalled = persisted?.terminalToolCalled ?? false;
+    let rejectedReceipts = persisted?.rejectedReceipts ?? [];
+    let recordedTurns = persisted?.deliveryTurns ?? 0;
+    if (scopeId.length > 0) {
+        const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+        const entries = await readBoundSessionEntries(sessionFile).catch(() => undefined);
+        if (entries !== undefined) {
+            const prior = priorReceiptContinuation(entries, scopeId);
+            terminalToolCalled = prior.terminalToolCalled;
+            rejectedReceipts = prior.rejectedReceipts;
+            recordedTurns = prior.deliveryTurns;
+        }
+    }
     const facts = noReceiptLifecycleFacts({
-        terminalToolCalled: false,
-        rejectedReceipts: [],
-        deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+        terminalToolCalled,
+        rejectedReceipts,
+        deliveryTurns: Math.max(issuedDeliveryRequests, recordedTurns),
         runPointer: admitted.runDirectory,
-        attemptPointer: `current:${admitted.runDirectory}`,
+        attemptPointer: receiptAttemptPointer(admitted.runDirectory, scope?.invocationScopeId),
     });
     const coordinates = coordinatesFromAdmitted(authority, admitted);
     await clearOppositeTerminalArtifactFace(admitted.runDirectory);
@@ -2286,48 +2373,24 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
     // current-attempt fact. Transcript reconstruction must not turn arbitrary output
     // failures (or bytes retained from a prior resume attempt) into exit zero.
     if (failure.cause === "output") {
-        const entries = await readBoundSessionEntries(sessionFile).catch(() => undefined);
-        if (entries !== undefined) {
-            let attemptStart = 0;
-            for (let index = entries.length - 1; index >= 0; index -= 1) {
-                if (entries[index]?.type === "message" && entries[index]?.message?.role === "user") {
-                    attemptStart = index;
-                    break;
-                }
-            }
-            const lifecycleEntry = entries.slice(attemptStart).reverse().find((entry) => entry.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE || entry.message?.customType === NO_RECEIPT_LIFECYCLE_ENTRY_TYPE);
-            const raw = lifecycleEntry?.data ?? lifecycleEntry?.message?.details;
-            if (raw !== undefined) {
-                // Catch only covers lifecycle-byte parse. Clear / navigator / gate I/O
-                // after a valid parse must keep their real failure identity (#953).
-                let facts;
-                try {
-                    facts = parseNoReceiptLifecycleFacts(raw);
-                }
-                catch {
-                    /* malformed lifecycle bytes remain the existing nonzero output failure */
-                }
-                if (facts !== undefined &&
-                    facts.runPointer === admitted.runDirectory &&
-                    facts.attemptPointer === `current:${admitted.runDirectory}`) {
-                    let decisiveFacts = facts;
-                    // #478: no_receipt is still a public Terminal — project accepted gate facts.
-                    // #953: empty public terminal face — clear every reader-adoptable prior face.
-                    await clearOppositeTerminalArtifactFace(admitted.runDirectory);
-                    return withOptionalGateProjection({
-                        roleOutcome: {
-                            kind: "no_receipt",
-                            role: admitted.role,
-                            status: "no-accepted-receipt",
-                            ...facts,
-                            decisiveFacts,
-                        },
-                        navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
-                        artifacts: [],
-                        runId: admitted.runId,
-                    }, sessionDirectory, detourGateContext(admitted, options));
-                }
-            }
+        const facts = await readCurrentAttemptNoReceiptFacts(admitted, authority, options);
+        if (facts !== undefined) {
+            const decisiveFacts = facts;
+            // #478: no_receipt is still a public Terminal — project accepted gate facts.
+            // #953: empty public terminal face — clear every reader-adoptable prior face.
+            await clearOppositeTerminalArtifactFace(admitted.runDirectory);
+            return withOptionalGateProjection({
+                roleOutcome: {
+                    kind: "no_receipt",
+                    role: admitted.role,
+                    status: "no-accepted-receipt",
+                    ...facts,
+                    decisiveFacts,
+                },
+                navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
+                artifacts: [],
+                runId: admitted.runId,
+            }, sessionDirectory, detourGateContext(admitted, options));
         }
     }
     // Exact-session attendance only — never infer no-advice from caller omission.

package/dist/public-cli/terminal.js

@@ -69,6 +69,17 @@ export function formatTerminalResult(result) {
     if (result.roleOutcome.kind === "failure") {
         lines.push(`diagnostic\t${encodeTerminalField(result.roleOutcome.diagnostic)}`);
     }
+    // Accepted volumes do not dump decisiveFacts unless a failed attempt is
+    // recorded. The unsettled-direction fact still has to be visible on its own.
+    // audit_escalation already dumps every decisiveFact below.
+    if (result.roleOutcome.kind === "accepted"
+        && result.roleOutcome.decisiveFacts?.directionUnsettled === true) {
+        lines.push("fact\tdirectionUnsettled\ttrue");
+        const subsequent = result.roleOutcome.decisiveFacts.subsequentAudit;
+        if (typeof subsequent === "string") {
+            lines.push(`fact\tsubsequentAudit\t${encodeTerminalField(subsequent)}`);
+        }
+    }
     if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation" || result.roleOutcome.decisiveFacts?.failedAttempts !== undefined) {
         const facts = result.roleOutcome.kind === "accepted"
             ? { failedAttempts: result.roleOutcome.decisiveFacts?.failedAttempts }
@@ -140,7 +151,7 @@ export function formatTerminalResult(result) {
     else {
         const payloads = result.roleOutcome.kind === "accepted" ||
             result.roleOutcome.kind === "audit_escalation"
-            ? coalesceSubmissionRows(result.roleOutcome.payloads, result.submissions)
+            ? coalesceSubmissionRows(result.submissions, result.roleOutcome.payloads)
             : result.submissions ?? [];
         for (let i = payloads.length - 1; i >= 0; i -= 1) {
             const payload = payloads[i];

package/dist/public-cli/turn-request.js

@@ -46,6 +46,9 @@ export function projectRoleTurnRequest(admitted, roleDetails, options) {
             ? {}
             : { invocationScopeId: options.invocationScopeId }),
         ...(options.stationChild === undefined ? {} : { stationChild: options.stationChild }),
+        ...(options.deliveryRequestLimit === undefined
+            ? {}
+            : { deliveryRequestLimit: options.deliveryRequestLimit }),
     };
 }
 /**

package/dist/receipt-delivery-policy.js

@@ -1,8 +1,33 @@
+import { AUTO_RESUME_LIMIT } from "./public-cli/run-lifecycle.js";
+import { parseAutoResumeLimit } from "./public-cli/config.js";
 import { isRecord } from "./unknown-value.js";
-const RECEIPT_DELIVERY_TURN_LIMIT = 2;
 const NO_RECEIPT_LIFECYCLE_ENTRY_TYPE = "ak-no-receipt-lifecycle";
+const RECEIPT_DELIVERY_REQUEST_ENTRY = "ak-receipt-delivery-request";
+const RECEIPT_REJECTION_ENTRY = "ak-receipt-rejection";
+function receiptAttemptPointer(runPointer, invocationScopeId) {
+  const scope = invocationScopeId?.trim() ?? "";
+  if (scope.length > 0) return `invocation:${scope}`;
+  return `current:${runPointer}`;
+}
+const RECEIPT_DELIVERY_LIMIT_ENV = "AK_ROLE_RECEIPT_DELIVERY_LIMIT";
+function deliveryLimitFromConfig(value) {
+  return parseAutoResumeLimit(value ?? AUTO_RESUME_LIMIT);
+}
+function deliveryLimitFromEnv(env) {
+  const raw = env[RECEIPT_DELIVERY_LIMIT_ENV];
+  if (raw === void 0 || raw.trim() === "") return deliveryLimitFromConfig(void 0);
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed)) return deliveryLimitFromConfig(void 0);
+  return deliveryLimitFromConfig(parsed);
+}
+function deliveryTurnsFact(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new TypeError("deliveryTurns must be a non-negative integer");
+  }
+  return value;
+}
 function parseNoReceiptLifecycleFacts(input) {
-  if (!isRecord(input) || typeof input.terminalToolCalled !== "boolean" || input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT || input.sessionCompletion !== "settled-without-accepted-receipt" || input.acceptedReceipt !== false || typeof input.runPointer !== "string" || input.runPointer.trim() === "" || typeof input.attemptPointer !== "string" || input.attemptPointer.trim() === "" || !Array.isArray(input.rejectedReceipts) || !input.rejectedReceipts.every((item) => isRecord(item) && typeof item.reason === "string")) {
+  if (!isRecord(input) || typeof input.terminalToolCalled !== "boolean" || input.sessionCompletion !== "settled-without-accepted-receipt" || input.acceptedReceipt !== false || typeof input.runPointer !== "string" || input.runPointer.trim() === "" || typeof input.attemptPointer !== "string" || input.attemptPointer.trim() === "" || !Array.isArray(input.rejectedReceipts) || !input.rejectedReceipts.every((item) => isRecord(item) && typeof item.reason === "string")) {
     throw new TypeError("malformed no-receipt lifecycle facts");
   }
   return {
@@ -11,7 +36,7 @@ function parseNoReceiptLifecycleFacts(input) {
       reason: item.reason,
       diagnosticAvailable: item.reason.trim() !== ""
     })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+    deliveryTurns: deliveryTurnsFact(input.deliveryTurns),
     sessionCompletion: "settled-without-accepted-receipt",
     runPointer: input.runPointer,
     attemptPointer: input.attemptPointer,
@@ -19,28 +44,33 @@ function parseNoReceiptLifecycleFacts(input) {
   };
 }
 function noReceiptLifecycleFacts(input) {
-  if (input.deliveryTurns !== RECEIPT_DELIVERY_TURN_LIMIT) {
-    throw new TypeError("no-receipt lifecycle requires an exhausted delivery budget");
-  }
   return {
     terminalToolCalled: input.terminalToolCalled,
     rejectedReceipts: input.rejectedReceipts.map(({ reason }) => ({
       reason,
       diagnosticAvailable: reason.trim() !== ""
     })),
-    deliveryTurns: RECEIPT_DELIVERY_TURN_LIMIT,
+    deliveryTurns: deliveryTurnsFact(input.deliveryTurns),
     sessionCompletion: "settled-without-accepted-receipt",
     runPointer: input.runPointer,
     attemptPointer: input.attemptPointer,
     acceptedReceipt: false
   };
 }
-function createReceiptDeliveryPolicy() {
+function createReceiptDeliveryPolicy(limit) {
+  const deliveryLimit = deliveryLimitFromConfig(limit);
   let accepted = false;
+  let closed = false;
   let terminalToolCalled = false;
   let deliveryTurns = 0;
+  let budgetSpent = 0;
   const rejectedReceipts = [];
+  const spend = () => {
+    if (budgetSpent < deliveryLimit) budgetSpent += 1;
+  };
   return {
+    /** The effective ceiling this budget spends (#1132 — never re-read). */
+    limit: deliveryLimit,
     recordAccepted() {
       accepted = true;
       terminalToolCalled = true;
@@ -49,27 +79,46 @@ function createReceiptDeliveryPolicy() {
     stopForInfrastructure() {
       accepted = true;
     },
+    /**
+     * Record the rejection this turn already produced.
+     * The fact does not spend a budget. The seam that sends the next prompt
+     * owns that count.
+     */
     recordRejected(reason) {
       terminalToolCalled = true;
       rejectedReceipts.push({ reason, diagnosticAvailable: reason.trim() !== "" });
-      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
     },
     recordDeliveryRequest() {
-      deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
+      deliveryTurns += 1;
+      spend();
     },
     /**
-     * A nested session settled without an accepted receipt after spending its own
-     * delivery budget. Adopt its facts and close this budget: another prompt would
-     * open an independent session, not a delivery request on the settled one.
+     * Stop asking. The issued count stays whatever was actually sent (#1132 —
+     * do not fill the remainder up to the ceiling).
+     */
+    closeBudget() {
+      closed = true;
+    },
+    /**
+     * A nested session settled without an accepted receipt. Close so this layer
+     * does not open another prompt on that session. The issued count stays the
+     * larger of the two seams: a nested zero must not wipe prompts this layer
+     * already sent, and adding the two counts would bill one send twice.
      */
     recordNestedNoReceipt(facts) {
       terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
       rejectedReceipts.push(...facts.rejectedReceipts);
-      deliveryTurns = RECEIPT_DELIVERY_TURN_LIMIT;
+      deliveryTurns = Math.max(deliveryTurns, facts.deliveryTurns);
+      closed = true;
     },
     nextAction() {
       if (accepted) return "accepted";
-      return deliveryTurns < RECEIPT_DELIVERY_TURN_LIMIT ? "request-delivery" : "no-receipt";
+      if (closed) return "no-receipt";
+      return budgetSpent < deliveryLimit ? "request-delivery" : "no-receipt";
+    },
+    /** Delivery requests actually issued so far (#1132). */
+    issuedDeliveryRequests() {
+      return deliveryTurns;
     },
     /** Current typed delivery facts. No prose. */
     deliveryState() {
@@ -82,13 +131,99 @@ function createReceiptDeliveryPolicy() {
     },
     facts(binding) {
       return noReceiptLifecycleFacts({ terminalToolCalled, rejectedReceipts: [...rejectedReceipts], deliveryTurns, ...binding });
+    },
+    /**
+     * Continue a public call after the in-memory policy was rebuilt.
+     * Sends already issued spend the same budget; copied rejections keep
+     * the fact and do not spend again.
+     */
+    continueIssued(prior) {
+      for (const receipt of prior.rejectedReceipts) {
+        this.recordRejected(receipt.reason);
+      }
+      if (prior.terminalToolCalled === true) terminalToolCalled = true;
+      for (let index = 0; index < prior.deliveryTurns; index += 1) {
+        this.recordDeliveryRequest();
+      }
     }
   };
 }
+function entryRecord(entry) {
+  return isRecord(entry) ? entry : void 0;
+}
+function customTypeOf(record, message) {
+  return record.customType ?? message?.customType;
+}
+function dataOf(record, message) {
+  return record.data ?? message?.details;
+}
+function scopeTag(record) {
+  const message = isRecord(record.message) ? record.message : void 0;
+  const customType = customTypeOf(record, message);
+  const data = dataOf(record, message);
+  if ((customType === RECEIPT_DELIVERY_REQUEST_ENTRY || customType === RECEIPT_REJECTION_ENTRY) && isRecord(data) && typeof data.invocationScopeId === "string" && data.invocationScopeId.trim() !== "") {
+    return data.invocationScopeId;
+  }
+  if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) return void 0;
+  try {
+    const facts = parseNoReceiptLifecycleFacts(data);
+    const prefix = "invocation:";
+    if (!facts.attemptPointer.startsWith(prefix)) return void 0;
+    const scope = facts.attemptPointer.slice(prefix.length);
+    return scope.trim() === "" ? void 0 : scope;
+  } catch {
+    return void 0;
+  }
+}
+function priorReceiptContinuation(entries, invocationScopeId) {
+  const pointer = receiptAttemptPointer("", invocationScopeId);
+  let entryTurns = 0;
+  let factTurns = 0;
+  let rejectedReceipts = [];
+  let snapshotTerminal = false;
+  for (const entry of entries) {
+    const record = entryRecord(entry);
+    if (record === void 0) continue;
+    const tagged = scopeTag(record);
+    if (tagged !== void 0) {
+      const message = isRecord(record.message) ? record.message : void 0;
+      const customType = customTypeOf(record, message);
+      if (tagged !== invocationScopeId) continue;
+      if (customType === RECEIPT_DELIVERY_REQUEST_ENTRY) entryTurns += 1;
+      if (customType === RECEIPT_REJECTION_ENTRY) {
+        const data = dataOf(record, message);
+        if (isRecord(data) && typeof data.reason === "string") rejectedReceipts.push({ reason: data.reason });
+      }
+      if (customType !== NO_RECEIPT_LIFECYCLE_ENTRY_TYPE) continue;
+      try {
+        const facts = parseNoReceiptLifecycleFacts(dataOf(record, message));
+        if (facts.attemptPointer !== pointer) continue;
+        factTurns = Math.max(factTurns, facts.deliveryTurns);
+        if (facts.rejectedReceipts.length >= rejectedReceipts.length) {
+          rejectedReceipts = facts.rejectedReceipts.map(({ reason }) => ({ reason }));
+        }
+        snapshotTerminal ||= facts.terminalToolCalled;
+      } catch {
+      }
+      continue;
+    }
+  }
+  return {
+    deliveryTurns: Math.max(entryTurns, factTurns),
+    rejectedReceipts,
+    terminalToolCalled: snapshotTerminal || rejectedReceipts.length > 0
+  };
+}
 export {
   NO_RECEIPT_LIFECYCLE_ENTRY_TYPE,
-  RECEIPT_DELIVERY_TURN_LIMIT,
+  RECEIPT_DELIVERY_LIMIT_ENV,
+  RECEIPT_DELIVERY_REQUEST_ENTRY,
+  RECEIPT_REJECTION_ENTRY,
   createReceiptDeliveryPolicy,
+  deliveryLimitFromConfig,
+  deliveryLimitFromEnv,
   noReceiptLifecycleFacts,
-  parseNoReceiptLifecycleFacts
+  parseNoReceiptLifecycleFacts,
+  priorReceiptContinuation,
+  receiptAttemptPointer
 };

package/dist/role-submission-declarations.js

@@ -0,0 +1,131 @@
+/**
+ * Field guidance for each public seat's submission tool (#1031).
+ * The tool name is the role registry's outputTool. This module does not restate it.
+ * Review seats keep the #1028 schema. Other seats keep their own field guidance.
+ * Execute lives in filed-submission.ts.
+ */
+import { packagedRoleOutputTool } from "./packaged-role-registry.js";
+import { reviewSubmissionSchema } from "./review-submission.js";
+import { collectorOutputArgsSchema } from "./collector-tool-schemas.js";
+import { diaristOutputSchema } from "./diarist-contracts.js";
+import { doctorSubmissionSchema, DOCTOR_OUTPUT_TOOL_DESCRIPTION } from "./doctor-contracts.js";
+import { fixerOutputSchema } from "./package-contracts/fixer-output.js";
+import { gatekeeperOutputSchema } from "./package-contracts/gatekeeper-output.js";
+import { gleanerLeftOutputSchema } from "./gleaner-left-contracts.js";
+import { mergerOutputSchema } from "./merger-contracts.js";
+import { navigatorOutputSchema } from "./package-contracts/navigator-output.js";
+import { reviewerOutputSchema } from "./package-contracts/reviewer-output.js";
+import { secretariatVerdictSchema } from "./secretariat-contracts.js";
+import { coderOutputSchema } from "./package-contracts/worker-output.js";
+const SUBMISSION_FACE = {
+    judge: {
+        label: "大理寺输出",
+        description: "提交大理寺终局判词；交卷调用结束后，由公开调用接缝按判词状态执行适用审核。",
+        promptSnippet: "提交大理寺终局判词",
+        parameters: reviewSubmissionSchema,
+    },
+    fixer: {
+        label: "修内司输出",
+        description: "提交修内司终局回执。",
+        promptSnippet: "提交修内司终局回执",
+        parameters: fixerOutputSchema,
+    },
+    coder: {
+        label: "将作监输出",
+        description: "提交将作监终局回执。",
+        promptSnippet: "提交将作监终局回执",
+        parameters: coderOutputSchema,
+    },
+    reviewer: {
+        label: "御史台输出",
+        description: "提交御史台终局回执。",
+        promptSnippet: "提交御史台终局回执",
+        parameters: reviewerOutputSchema,
+    },
+    collector: {
+        label: "通进司输出",
+        description: "提交通进司回执。",
+        promptSnippet: "提交通进司回执",
+        parameters: collectorOutputArgsSchema,
+    },
+    doctor: {
+        label: "太医署输出",
+        description: DOCTOR_OUTPUT_TOOL_DESCRIPTION,
+        parameters: doctorSubmissionSchema,
+    },
+    merger: {
+        label: "合并输出",
+        description: "提交合并结果；输出分支为 completed 与 escalate。",
+        promptSnippet: "提交合并结果",
+        parameters: mergerOutputSchema,
+    },
+    notary: {
+        label: "符宝郎输出",
+        description: "提交引文保真与票面对齐的 converged/continue/escalate 决议。",
+        promptSnippet: "提交符宝郎决议",
+        parameters: reviewSubmissionSchema,
+    },
+    countersign: {
+        label: "给事中输出",
+        description: "给事中决议。",
+        promptSnippet: "给事中决议",
+        parameters: reviewSubmissionSchema,
+    },
+    secretariat: {
+        label: "中书省输出",
+        description: "中书省终局回执。",
+        promptSnippet: "中书省终局回执",
+        parameters: secretariatVerdictSchema,
+    },
+    "gleaner-left": {
+        label: "左拾遗输出",
+        description: "左拾遗弹章。",
+        promptSnippet: "左拾遗弹章",
+        parameters: gleanerLeftOutputSchema,
+    },
+    inspector: {
+        label: "台院输出",
+        description: "台院终局回执，状态为 converged、continue 或 escalate。",
+        promptSnippet: "台院终局回执",
+        parameters: reviewSubmissionSchema,
+    },
+    gatekeeper: {
+        label: "门下省决议",
+        description: "门下省终局决议。status 为 dispatch 或 pass。",
+        promptSnippet: "门下省决议",
+        parameters: gatekeeperOutputSchema,
+    },
+    navigator: {
+        label: "游奕使建议",
+        description: "游奕使终局回执：散文建议，原样呈现。",
+        promptSnippet: "游奕使建议",
+        parameters: navigatorOutputSchema,
+    },
+    auditor: {
+        label: "审刑院输出",
+        description: "审刑院终局回执，status 为 converged、continue 或 escalate。",
+        promptSnippet: "审刑院终局回执",
+        parameters: reviewSubmissionSchema,
+    },
+    diarist: {
+        label: "起居郎输出",
+        description: "起居郎交单票 sessions 或多票逐票 ticketSessions 边界；认不出本庭对象则 escalate。",
+        promptSnippet: "起居郎交边界",
+        parameters: diaristOutputSchema,
+    },
+};
+/** Tool name comes from the registry record. Label and schema stay on this face. */
+export function roleSubmissionDeclaration(role) {
+    const name = packagedRoleOutputTool(role);
+    if (name === undefined)
+        throw new Error(`${role} output tool is not declared`);
+    const face = SUBMISSION_FACE[role];
+    return {
+        role,
+        name,
+        label: face.label,
+        description: face.description,
+        ...("promptSnippet" in face ? { promptSnippet: face.promptSnippet } : {}),
+        parameters: face.parameters,
+    };
+}

package/dist/secretariat-contracts.js

@@ -1,8 +1,30 @@
+import { Type } from "typebox";
+import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.js";
 const SECRETARIAT_OUTPUT_TOOL_NAME = "ak_secretariat_output";
+const secretariatVerdictSchema = withTerminatingOutputDeclarations(
+  Type.Object(
+    {
+      secretariatStatus: Type.Unknown({
+        description: "converged | escalate"
+      }),
+      ticketNumber: Type.Optional(
+        Type.Unknown({ description: "\u672C\u7968\u53F7\uFF1B\u7F72\u65F6\u6307\u5411\u6700\u7EC8\u6B63\u6587\u6240\u5728\u7968" })
+      ),
+      note: Type.Unknown({ description: "\u9644\u6CE8" }),
+      evidence: Type.Optional(Type.Unknown({ description: "\u7559\u5B58\u8BC1\u636E" })),
+      decisionGate: Type.Unknown({
+        description: "\u9700\u965B\u4E0B\u5904\u7F6E\u7684\u95EE\u9898\u4E0E\u9009\u9879\uFF1B\u53EF\u5199 question \u4E0E options\uFF0C\u539F\u6837\u7559\u5B58\u3002"
+      })
+    },
+    { additionalProperties: true }
+  )
+);
+secretariatVerdictSchema.required = [];
 const SECRETARIAT_GATE_OFFICER_ENTRY_TYPE = "ak-secretariat-gate-officer";
 const SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY = "countersignTerminal";
 export {
   SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY,
   SECRETARIAT_GATE_OFFICER_ENTRY_TYPE,
-  SECRETARIAT_OUTPUT_TOOL_NAME
+  SECRETARIAT_OUTPUT_TOOL_NAME,
+  secretariatVerdictSchema
 };

package/dist/submission-errors.js

@@ -44,10 +44,20 @@ export class WorkerPrefixReminderError extends Error {
         this.name = "WorkerPrefixReminderError";
     }
 }
+/**
+ * ADR 0066/0070 one-shot commit and prefix reminders.
+ * They stay a correction the same session may make, and they do not occupy
+ * the configured re-ask or 催交 budget (#1132).
+ */
+export function isOneShotWorkerReminderCode(code) {
+    return code === "worker_commit_reminder" || code === "worker_prefix_reminder";
+}
 export class WorkerUnfinishedReasonReminderError extends Error {
     code = "worker_unfinished_reason_reminder";
     constructor() {
-        super("本次 unfinished 回执未含 reason；本接缝缺由至多打回两次。");
+        // The ceiling is the configured unfinished-reason limit. This text reaches
+        // the model and does not restate a count.
+        super("本次 unfinished 回执未含 reason；请补上 reason 后再交。");
         this.name = "WorkerUnfinishedReasonReminderError";
     }
 }