@akagilnc/pi-workflow-roles 0.1.4321 → 0.1.4387

package/src/public-cli/secretariat-run.ts

@@ -0,0 +1,266 @@
+/**
+ * Public Secretariat (中书省) Role run: admit → 起居郎 typed identity → bind/relocate
+ * → shared post-admission (dossier delivery) → settle (#924).
+ * Instruction-seat face like Judge; nested countersign is role-tool driven.
+ * Ticket identity reuses the court diarist seam (no prose regex; no second lifecycle).
+ */
+import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
+import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.ts";
+import { CliUsageError } from "./cli-errors.ts";
+import {
+  admitSecretariatInvocation,
+  bindAdmittedTicketNumber,
+  buildSecretariatTransportPrompt,
+  relocateAdmittedRunToTicket,
+  type AdmittedSecretariatInvocation,
+  type ParseSecretariatArgvResult,
+} from "./invocation.ts";
+import {
+  invokeCourtDiarist,
+  type CourtDiaristSummonEnv,
+} from "./countersign-run.ts";
+import {
+  presentControlledFailure,
+  runPostAdmissionOneShot,
+  type PostAdmissionEnv,
+  runPostAdmissionSeatResume,
+  resumeTurnRequestProjectionOptions,
+} from "./post-admission.ts";
+import {
+  loadResumableSecretariatRun,
+  markRunAdmitted,
+  type PublicResumeRequest,
+} from "./run-lifecycle.ts";
+import {
+  presentStructuralRejection,
+  trySettleSecretariatTerminalResult,
+} from "./settlement.ts";
+import type { CliIo } from "./cli-io.ts";
+import type { TerminalResult } from "./terminal.ts";
+import {
+  projectRoleTurnRequest,
+  type RoleTurnRequestProjectionOptions,
+} from "./turn-request.ts";
+
+export type SecretariatRunEnv = PostAdmissionEnv & {
+  principalAuthority: DurablePrincipalAuthority;
+  createRunId?: () => string;
+};
+
+/** Project admitted invocation onto the host-neutral turn request. */
+export function buildSecretariatTurnRequest(
+  admitted: AdmittedSecretariatInvocation,
+  options: RoleTurnRequestProjectionOptions,
+): RoleTurnRequest {
+  return projectRoleTurnRequest(
+    admitted,
+    {
+      activation: {
+        role: "secretariat" as const,
+        ...(admitted.ticketNumber === undefined
+          ? {}
+          : { ticketNumber: admitted.ticketNumber }),
+      },
+    },
+    options,
+  );
+}
+
+function diaristEnv(env: SecretariatRunEnv): CourtDiaristSummonEnv {
+  return {
+    cwd: env.cwd,
+    home: env.home,
+    agentDir: env.agentDir,
+    packageRoot: env.packageRoot,
+    ...(env.credentials === undefined ? {} : { credentials: env.credentials }),
+    ...(env.signal === undefined ? {} : { signal: env.signal }),
+    ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
+  };
+}
+
+export async function runPublicSecretariat(
+  argv: readonly string[],
+  env: SecretariatRunEnv,
+  io: CliIo,
+  parseSecretariatArgv: (args: readonly string[]) => ParseSecretariatArgvResult,
+): Promise<{
+  exitCode: number;
+  admitted?: AdmittedSecretariatInvocation;
+  terminal?: TerminalResult;
+}> {
+  let parsed: ParseSecretariatArgvResult;
+  try {
+    parsed = parseSecretariatArgv(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  let admitted: AdmittedSecretariatInvocation;
+  try {
+    admitted = await admitSecretariatInvocation({
+      home: env.home,
+      principalAuthority: env.principalAuthority,
+      cwd: env.cwd,
+      instruction: parsed.instruction,
+      attachmentPaths: parsed.attachmentPaths,
+      ...(parsed.project === undefined ? {} : { project: parsed.project }),
+      ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
+      ...(env.model === undefined ? {} : { model: env.model }),
+      ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
+    });
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  await markRunAdmitted(admitted, env.principalAuthority);
+
+  // #924 G3 / ADR 0075 / 0081: ticket identity is 起居郎 typed assertion — never
+  // prose regex. escalate / real station failure → controlled failure; lawful
+  // true-unbound continues unbound (ADR 0075 真无票→无录; 第 0 条不拒收);
+  // ticket → bind + relocate so post-admission can deliver 起居录.
+  const outcome = await invokeCourtDiarist(
+    {
+      instruction: parsed.instruction,
+      projectRoot: admitted.projectRoot,
+      failureLabel: "secretariat unbound summons",
+      attachmentPaths: admitted.attachments.map((attachment) => attachment.frozenPath),
+      correlationId: admitted.runId,
+    },
+    diaristEnv(env),
+    io,
+  );
+
+  if (outcome.identity.kind === "escalate") {
+    return await presentControlledFailure(
+      admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: new Error(
+          "court diarist station escalated (cannot identify court target)",
+        ),
+      },
+      secretariatAdapters(),
+      env.principalAuthority,
+      io,
+    );
+  }
+
+  if (outcome.failedWithoutEscalate !== undefined) {
+    return await presentControlledFailure(
+      admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: new Error(outcome.failedWithoutEscalate.diagnostic),
+      },
+      secretariatAdapters(),
+      env.principalAuthority,
+      io,
+    );
+  }
+
+  if (outcome.identity.kind === "ticket") {
+    try {
+      await bindAdmittedTicketNumber(admitted, outcome.identity.ticketNumber);
+      await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
+    } catch (error) {
+      return await presentControlledFailure(
+        admitted,
+        {
+          timedOut: false,
+          code: null,
+          stderr: "",
+          thrown: error,
+        },
+        secretariatAdapters(),
+        env.principalAuthority,
+        io,
+      );
+    }
+  }
+
+  const turnRequest = buildSecretariatTurnRequest(admitted, {
+    packageRoot: env.packageRoot,
+    home: env.home,
+    agentDir: env.agentDir,
+    ...(env.model === undefined ? {} : { model: env.model }),
+    ...pickEngineAxis(env),
+    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
+    ...(env.correlationId === undefined || env.correlationId.trim() === ""
+      ? {}
+      : { correlationId: env.correlationId }),
+    continuation: {
+      kind: "initial",
+      prompt: buildSecretariatTransportPrompt(
+        admitted,
+        engineSessionMaterialFromOptions({
+          ...pickEngineAxis(env),
+          packageRoot: env.packageRoot,
+        }),
+      ),
+    },
+  });
+
+  return await runPostAdmissionOneShot({
+    admitted,
+    env,
+    io,
+    request: turnRequest,
+    adapters: secretariatAdapters(),
+    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+  });
+}
+
+function secretariatAdapters() {
+  return {
+    trySettle: (
+      admitted: AdmittedSecretariatInvocation,
+      authority: DurablePrincipalAuthority,
+      scope?: { readonly courtAttemptId?: string },
+    ) => trySettleSecretariatTerminalResult(admitted, authority, scope),
+    shouldPresentSettled: () => true,
+  };
+}
+
+/**
+ * Resume a previously admitted Secretariat run (#599).
+ */
+export async function runPublicSecretariatResume(
+  request: PublicResumeRequest,
+  env: SecretariatRunEnv,
+  io: CliIo,
+): Promise<{
+  exitCode: number;
+  admitted?: AdmittedSecretariatInvocation;
+  terminal?: TerminalResult;
+}> {
+  return await runPostAdmissionSeatResume({
+    request,
+    env,
+    io,
+    load: (effective) =>
+      loadResumableSecretariatRun(
+        env.home,
+        effective.runId,
+        env.principalAuthority,
+      ),
+    buildTurnRequest: (admitted, effective) =>
+      buildSecretariatTurnRequest(
+        admitted,
+        resumeTurnRequestProjectionOptions(admitted, effective, env),
+      ),
+    adapters: secretariatAdapters(),
+    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+  });
+}

package/src/public-cli/settlement.ts

@@ -94,6 +94,9 @@ import {
 import {
   DIARIST_OUTPUT_TOOL_NAME,
 } from "../diarist-contracts.ts";
+import {
+  SECRETARIAT_OUTPUT_TOOL_NAME,
+} from "../secretariat-contracts.ts";
 import {
   INSPECTOR_OUTPUT_TOOL_NAME,
 } from "../inspector-contracts.ts";
@@ -146,6 +149,7 @@ import {
   type AdmittedMergerInvocation,
   type AdmittedCountersignInvocation,
   type AdmittedDiaristInvocation,
+  type AdmittedSecretariatInvocation,
   type AdmittedGleanerLeftInvocation,
   type AdmittedInspectorInvocation,
   type AdmittedGatekeeperInvocation,
@@ -1086,38 +1090,7 @@ async function loadBoundAuditorVolumes(
   }
   const parentId = parentEntries.find((entry) => entry.type === "session")?.id;
   if (parentId === undefined) return undefined;
-  const isResumeEnvelopeBytes = (value: unknown): boolean => {
-    if (typeof value !== "string") return false;
-    if (value.length === 0) return true;
-    const nl = value.indexOf("\n");
-    const firstLine = nl === -1 ? value : value.slice(0, nl);
-    const body = firstLine === "" && nl !== -1 ? value.slice(nl + 1) : value;
-    return body.startsWith("本次配置的劳务引擎及其手册：") || body.startsWith("- engine:");
-  };
-  const isResumeEnvelope = (msg: unknown): boolean => {
-    if (!isRecord(msg) || msg.role !== "user") return false;
-    const text = typeof msg.text === "string" ? msg.text : typeof (msg as { content?: unknown }).content === "string" ? (msg as { content: string }).content : undefined;
-    if (isResumeEnvelopeBytes(text)) return true;
-    const content = (msg as { content?: unknown }).content;
-    if (Array.isArray(content)) {
-      return content.some((p) => isRecord(p) && (isResumeEnvelopeBytes(p.text) || isResumeEnvelopeBytes(p.content)));
-    }
-    return false;
-  };
-  let latestParentUserIndex = -1;
-  for (let i = parentEntries.length - 1; i >= 0; i -= 1) {
-    const entry = parentEntries[i];
-    if (entry?.type !== "message" || entry.message?.role !== "user") continue;
-    if (isResumeEnvelope(entry.message)) continue;
-    latestParentUserIndex = i;
-    break;
-  }
   const childDirectories = [join(dirname(sessionFile), "auditor-roles")];
-  // Auto-resume seam (owner A): stale check must ignore resume envelope and
-  // prioritize retention. Previous `attemptEntryIndex < latest` discarded the
-  // first attempt's child after resume advanced latest, losing retentionFailure
-  // when retry had no compliance entry. Fix: ignore envelope for staleness and
-  // prefer any valid compliance failure before falling back to primary.
   const valid: BoundAuditorVolume[] = [];
   let sawAnyDirectory = false;
   for (const childDirectory of childDirectories) {
@@ -1166,10 +1139,6 @@ async function loadBoundAuditorVolumes(
           typeof bindingParent?.attemptEntryId === "string"
             ? bindingParent.attemptEntryId
             : undefined;
-        const attemptEntryIndex =
-          attemptEntryId === undefined
-            ? -1
-            : parentEntries.findIndex((entry) => entry.id === attemptEntryId);
         const boundSessionFile =
           typeof bindingParent?.sessionFile === "string"
             ? bindingParent.sessionFile
@@ -1177,12 +1146,7 @@ async function loadBoundAuditorVolumes(
               ? header.parentSession
               : undefined;
         if (boundSessionFile !== sessionFile) continue;
-        if (
-          bindingParent !== undefined &&
-          (bindingParent.sessionId !== parentId || attemptEntryIndex < latestParentUserIndex)
-        ) {
-          continue;
-        }
+        if (bindingParent !== undefined && bindingParent.sessionId !== parentId) continue;
         if (bindingParent === undefined && header.parentSession !== sessionFile) continue;
         valid.push({
           entries: entries.slice(start, end),
@@ -1190,8 +1154,8 @@ async function loadBoundAuditorVolumes(
           sessionFile,
           ...(attemptEntryId === undefined ? {} : { attemptEntryId }),
         });
-        // Keep every qualifying interval in the current parent-user range.
-        // A single first-match break drops later same-user summons failures (#636).
+        // Keep every interval bound to this parent. Auditor payload is relayed as
+        // recorded; code does not expire it from later user-message shape (#858).
       }
     }
   }
@@ -1254,16 +1218,6 @@ function providerStopFallbackFromAuditorVolumes(
   return undefined;
 }
 
-/** Recover a provider stop from the auditor child bound to the current parent attempt. */
-export async function readBoundAuditorKnownFailure(
-  sessionFile: string,
-): Promise<RoleTurnKnownFailure | undefined> {
-  const volumes = await loadBoundAuditorVolumes(sessionFile);
-  if (volumes === undefined) return undefined;
-  return complianceFailureFromAuditorVolumes(volumes)
-    ?? providerStopFallbackFromAuditorVolumes(volumes);
-}
-
 /** Strong auditor tier only — retained compliance-failure entries, no provider-stop fallback. */
 async function readBoundAuditorComplianceFailure(
   sessionFile: string,
@@ -3193,7 +3147,8 @@ type SeatAcceptedSettlementSpec = {
     | "gatekeeper"
     | "navigator"
     | "auditor"
-    | "diarist";
+    | "diarist"
+    | "secretariat";
   readonly toolName: string;
 };
 
@@ -3217,7 +3172,8 @@ async function settleLawfulSeatAcceptedTerminalResult(
     | AdmittedGatekeeperInvocation
     | AdmittedNavigatorInvocation
     | import("./invocation.ts").AdmittedAuditorInvocation
-    | AdmittedDiaristInvocation,
+    | AdmittedDiaristInvocation
+    | AdmittedSecretariatInvocation,
   authority: DurablePrincipalAuthority,
   spec: SeatAcceptedSettlementSpec,
   scope?: SettlementCourtScope,
@@ -3434,6 +3390,26 @@ export async function trySettleDiaristTerminalResult(
   return settleLawfulDiaristTerminalResult(admitted, authority, scope);
 }
 
+async function settleLawfulSecretariatTerminalResult(
+  admitted: AdmittedSecretariatInvocation,
+  authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
+): Promise<TerminalResult | undefined> {
+  return settleLawfulSeatAcceptedTerminalResult(admitted, authority, {
+    role: "secretariat",
+    toolName: SECRETARIAT_OUTPUT_TOOL_NAME,
+  }, scope);
+}
+
+/** Try to settle a lawful Secretariat Terminal; undefined only for genuine absence. */
+export async function trySettleSecretariatTerminalResult(
+  admitted: AdmittedSecretariatInvocation,
+  authority: DurablePrincipalAuthority,
+  scope?: SettlementCourtScope,
+): Promise<TerminalResult | undefined> {
+  return settleLawfulSecretariatTerminalResult(admitted, authority, scope);
+}
+
 /** Lawful Inspector accepted outcome (pass/bounce/escalate). */
 export type LawfulInspectorRoleOutcome = Extract<TerminalRoleOutcome, { kind: "accepted" }>;
 

package/src/public-cli/terminal.ts

@@ -42,7 +42,8 @@ export type TerminalRoleName =
   | "gatekeeper"
   | "navigator"
   | "auditor"
-  | "diarist";
+  | "diarist"
+  | "secretariat";
 
 export type NoReceiptTerminalOutcome = NoReceiptLifecycleFacts & {
   kind: "no_receipt";

package/src/public-role-summons.ts

@@ -32,7 +32,8 @@ export type PublicSummonRole =
   | "gatekeeper"
   | "judge"
   | "doctor"
-  | "diarist";
+  | "diarist"
+  | "countersign";
 
 export type PublicSummonRequest = {
   readonly role: PublicSummonRole;
@@ -82,6 +83,8 @@ export type PublicSummonRequest = {
   readonly createRunId?: () => string;
   /** Typed ticket number handoff for diarist child run (#840). */
   readonly boundTicketNumber?: number;
+  /** Caller correlation id for nested leg ledger (ADR 0010 / #924). */
+  readonly correlationId?: string;
 };
 
 export type PublicSummonResult = {
@@ -339,6 +342,11 @@ export async function summonPublicRole(
         env: {
           ...built.env,
           stationChild: true,
+          // Forward composition-root adapters so nested court stations (e.g.
+          // countersign → diarist) select the same faux/production table (#924).
+          ...(options.hostAdapters === undefined
+            ? {}
+            : { hostAdapters: options.hostAdapters }),
           ...(config.autoResumeLimit === undefined
             ? {}
             : { autoResumeLimit: config.autoResumeLimit }),
@@ -350,6 +358,9 @@ export async function summonPublicRole(
           ...(options.boundTicketNumber === undefined
             ? {}
             : { boundTicketNumber: options.boundTicketNumber }),
+          ...(options.correlationId === undefined || options.correlationId.trim() === ""
+            ? {}
+            : { correlationId: options.correlationId }),
           ...(options.createRunId === undefined ? {} : { createRunId: options.createRunId }),
         },
       };
@@ -481,6 +492,17 @@ export async function summonPublicRole(
       result = stepped.ok;
       break;
     }
+    case "countersign": {
+      const [{ runPublicCountersign }, { parseCountersignArgv }] = await Promise.all([
+        import("./public-cli/countersign-run.ts"),
+        import("./public-cli/invocation.ts"),
+      ]);
+      const stepped = await runPrepared(parseCountersignArgv, (env, once) =>
+        runPublicCountersign(options.argv, env as never, io, once));
+      if ("fail" in stepped) return stepped.fail;
+      result = stepped.ok;
+      break;
+    }
   }
 
   const stderr = captured?.stderrText();

package/src/reviewer-role.ts

@@ -1,7 +1,7 @@
 import type { RoleHost, HostContext, HostToolResult } from "./host-contracts.ts";
 import { Type } from "typebox";
 import { openToolObjectFromUnion } from "./open-tool-schema.ts";
-import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.ts";
+import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.ts";
 
 import type { AnyCanonicalSkillBinding, CanonicalSkillBinding } from "./canonical-skill-binding.ts";
 export type { CanonicalSkillBinding };
@@ -43,7 +43,7 @@ const reviewerOutputVariants = Type.Union([
     amendments: Type.Optional(reviewerAmendmentsSchema),
   }, { additionalProperties: false }),
 ]);
-export const reviewerOutputSchema = withInfrastructureFailureDeclaration(
+export const reviewerOutputSchema = withTerminatingOutputDeclarations(
   openToolObjectFromUnion(reviewerOutputVariants),
 );
 export type ReviewerRoleDependencies = {

package/src/role-runtime-dependencies.ts

@@ -47,6 +47,7 @@ export function createRoleRuntimeDependencies(packageRoot: string): RoleRuntimeD
     loadCountersignSoul: () => loadMainRoleSessionMaterials("countersign"),
     loadGleanerLeftSoul: () => loadMainRoleSessionMaterials("gleaner-left"),
     loadDiaristSoul: () => loadMainRoleSessionMaterials("diarist"),
+    loadSecretariatSoul: () => loadMainRoleSessionMaterials("secretariat"),
     loadNotarySourceRun: loadNotarySourceRunLocator,
     loadMergerSoul: () => loadMainRoleSessionMaterials("merger"),
     loadMergerInput: async (path) => JSON.parse(await readFile(path, "utf8")),