@akagilnc/pi-workflow-roles 0.1.3452 → 0.1.3471

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

@@ -23,9 +23,15 @@ import {
   type AdmittedCountersignInvocation,
   type ParseCountersignArgvResult,
 } from "./invocation.ts";
-import { resolveSeatTicketBinding } from "./seat-ticket-binding.ts";
+import {
+  applyInstructionTicketProbe,
+  probeInstructionTicket,
+  ticketNumberFromProbe,
+  tryResumeSameTicketSeatRun,
+} from "./seat-ticket-binding.ts";
 import { tryHomeFromAkRolesPath } from "../activation-ledger-topology.ts";
 import {
+  prepareSummonsResumeMaterials,
   runPostAdmissionOneShot,
   type PostAdmissionEnv,
   runPostAdmissionSeatResume,
@@ -35,6 +41,7 @@ import {
   loadResumableCountersignRun,
   markRunAdmitted,
   type PublicResumeRequest,
+  type SameTicketSummonsMaterials,
 } from "./run-lifecycle.ts";
 import {
   presentStructuralRejection,
@@ -82,9 +89,52 @@ export async function runPublicCountersign(
   admitted?: AdmittedCountersignInvocation;
   terminal?: TerminalResult;
 }> {
+  let parsed: ParseCountersignArgvResult;
+  try {
+    parsed = parseCountersignArgv(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  // #637: same ticket → resume prior countersign run with this summons' materials.
+  // Probe captures DiaristTicketResolutionError so admit+beforeDispatch can settle
+  // controlled failure (bare pre-admit throw skips terminal settlement).
+  // No bare catch→fresh: lookup/resume failures surface; only true absence mints new.
+  const projectRoot = parsed.project ?? env.cwd;
+  const ticketProbe = await probeInstructionTicket(
+    parsed.instruction,
+    projectRoot,
+    env,
+  );
+  const probedTicketNumber = ticketNumberFromProbe(ticketProbe);
+  if (probedTicketNumber !== undefined) {
+    const summons: SameTicketSummonsMaterials = {
+      instruction: parsed.instruction,
+      instructionEmpty: parsed.instruction.trim() === "",
+      attachmentPaths: parsed.attachmentPaths,
+    };
+    const resumed = await tryResumeSameTicketSeatRun({
+      home: env.home,
+      projectRoot,
+      role: "countersign",
+      ticketNumber: probedTicketNumber,
+      summons,
+      resume: (runId, materials) =>
+        runPublicCountersignResume(
+          { runId, ...(materials === undefined ? {} : { summons: materials }) },
+          env,
+          io,
+        ),
+    });
+    if (resumed !== undefined) return resumed;
+  }
+
   let admitted: AdmittedCountersignInvocation;
   try {
-    const parsed = parseCountersignArgv(argv);
     admitted = await admitCountersignInvocation({
       home: env.home,
       principalAuthority: env.principalAuthority,
@@ -127,7 +177,7 @@ export async function runPublicCountersign(
       ),
     },
   };
-  // Mutable shell: pre-court ticket resolution may rebind activation before executeTurn.
+  // Mutable shell: ticket bind re-projects activation before executeTurn.
   const turnRequest = buildCountersignTurnRequest(admitted, turnProjection);
 
   return await runPostAdmissionOneShot({
@@ -137,8 +187,8 @@ export async function runPublicCountersign(
     request: turnRequest,
     adapters: countersignAdapters({
       beforeDispatch: async (admitted) => {
-        await resolveSeatTicketBinding(admitted, env);
-        // Re-project activation so Notary gate flag carries the post-admission binding.
+        // #635/#637: apply pre-admit probe inside controlled-failure boundary.
+        await applyInstructionTicketProbe(admitted, ticketProbe);
         Object.assign(
           turnRequest,
           buildCountersignTurnRequest(admitted, turnProjection),
@@ -156,8 +206,11 @@ function countersignAdapters(options?: {
   ) => void | Promise<void>;
 }) {
   return {
-    trySettle: (admitted: AdmittedCountersignInvocation, authority: DurablePrincipalAuthority) =>
-      trySettleCountersignTerminalResult(admitted, authority),
+    trySettle: (
+      admitted: AdmittedCountersignInvocation,
+      authority: DurablePrincipalAuthority,
+      scope?: { readonly courtAttemptId?: string },
+    ) => trySettleCountersignTerminalResult(admitted, authority, scope),
     // Accepted receipts and failure terminals both present via shared path.
     shouldPresentSettled: () => true,
     ...(options?.beforeDispatch === undefined
@@ -167,8 +220,11 @@ function countersignAdapters(options?: {
 }
 
 /**
- * Resume a previously admitted Countersign run (#599 / DK-3).
- * Restores role/ticket/attachments/session identity; diarist does not re-run.
+ * Resume a previously admitted Countersign run (#599 / DK-3 / #637).
+ * Restores role/ticket/session identity. Every court re-entry runs the diarist
+ * station first (ADR 0075 refresh-every-court). Same-ticket summons deliver this
+ * turn's instruction + frozen attachments on the resume prompt; manual resume
+ * keeps package-envelope / caller-message semantics and birth attachments.
  */
 export async function runPublicCountersignResume(
   request: PublicResumeRequest,
@@ -183,18 +239,32 @@ export async function runPublicCountersignResume(
     request,
     env,
     io,
-    load: () =>
+    load: (effective) =>
       loadResumableCountersignRun(
-      env.home,
-      request.runId,
-      env.principalAuthority,
-    ),
-    buildTurnRequest: (admitted) =>
-      buildCountersignTurnRequest(
-      admitted,
-      resumeTurnRequestProjectionOptions(admitted, request, env),
-    ),
-    adapters: countersignAdapters(),
+        env.home,
+        effective.runId,
+        env.principalAuthority,
+      ),
+    buildTurnRequest: async (admitted, effective) => {
+      const summonsPrepared = await prepareSummonsResumeMaterials(
+        admitted.runDirectory,
+        effective.summons,
+      );
+      return buildCountersignTurnRequest(
+        admitted,
+        resumeTurnRequestProjectionOptions(
+          admitted,
+          effective,
+          env,
+          summonsPrepared,
+        ),
+      );
+    },
+    adapters: countersignAdapters({
+      beforeDispatch: async (admitted) => {
+        await runCountersignDiaristStation(admitted, env);
+      },
+    }),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }

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

@@ -143,16 +143,16 @@ export async function runPublicDoctorResume(
     request,
     env,
     io,
-    load: () =>
+    load: (effective) =>
       loadResumableDoctorRun(
       env.home,
-      request.runId,
+      effective.runId,
       env.principalAuthority,
     ),
-    buildTurnRequest: (admitted) =>
+    buildTurnRequest: (admitted, effective) =>
       buildDoctorTurnRequest(
       admitted,
-      resumeTurnRequestProjectionOptions(admitted, request, env),
+      resumeTurnRequestProjectionOptions(admitted, effective, env),
     ),
     adapters: doctorAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),

package/src/public-cli/gleaner-left-run.ts

@@ -124,8 +124,11 @@ export async function runPublicGleanerLeft(
 
 function gleanerLeftAdapters() {
   return {
-    trySettle: (admitted: AdmittedGleanerLeftInvocation, authority: DurablePrincipalAuthority) =>
-      trySettleGleanerLeftTerminalResult(admitted, authority),
+    trySettle: (
+      admitted: AdmittedGleanerLeftInvocation,
+      authority: DurablePrincipalAuthority,
+      scope?: { readonly courtAttemptId?: string },
+    ) => trySettleGleanerLeftTerminalResult(admitted, authority, scope),
     shouldPresentSettled: () => true,
   };
 }
@@ -147,16 +150,16 @@ export async function runPublicGleanerLeftResume(
     request,
     env,
     io,
-    load: () =>
+    load: (effective) =>
       loadResumableGleanerLeftRun(
       env.home,
-      request.runId,
+      effective.runId,
       env.principalAuthority,
     ),
-    buildTurnRequest: (admitted) =>
+    buildTurnRequest: (admitted, effective) =>
       buildGleanerLeftTurnRequest(
       admitted,
-      resumeTurnRequestProjectionOptions(admitted, request, env),
+      resumeTurnRequestProjectionOptions(admitted, effective, env),
     ),
     adapters: gleanerLeftAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),

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

@@ -3,12 +3,17 @@
  * coordinator → settle Terminal result (#568 / ADR 0074). Lawful releases:
  * pass/bounce/escalate. #633: manual resume continues the exact session. Dual path
  * with gate-province dispatch; this module is the direct command face.
+ * #637: same-ticket re-summons resume the seat's previous run (no new run).
  */
 import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
 import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.ts";
-import { rebindAdmittedToTicketSeatMemory } from "../ticket-seat-memory.ts";
 import { CliUsageError } from "./cli-errors.ts";
-import { resolveSeatTicketBinding } from "./seat-ticket-binding.ts";
+import {
+  applyInstructionTicketProbe,
+  probeInstructionTicket,
+  ticketNumberFromProbe,
+  tryResumeSameTicketSeatRun,
+} from "./seat-ticket-binding.ts";
 import {
   admitInspectorInvocation,
   buildInspectorTransportPrompt,
@@ -16,6 +21,7 @@ import {
   type ParseInspectorArgvResult,
 } from "./invocation.ts";
 import {
+  prepareSummonsResumeMaterials,
   runPostAdmissionOneShot,
   type PostAdmissionAdapters,
   type PostAdmissionEnv,
@@ -26,6 +32,7 @@ import {
   loadResumableInspectorRun,
   markRunAdmitted,
   type PublicResumeRequest,
+  type SameTicketSummonsMaterials,
 } from "./run-lifecycle.ts";
 import {
   presentStructuralRejection,
@@ -69,9 +76,52 @@ export async function runPublicInspector(
   admitted?: AdmittedInspectorInvocation;
   terminal?: TerminalResult;
 }> {
+  let parsed: ParseInspectorArgvResult;
+  try {
+    parsed = parseInspectorArgv(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  // #637: same ticket → resume prior inspector run with this summons' materials.
+  // Probe captures DiaristTicketResolutionError so admit+beforeDispatch can settle
+  // controlled failure (bare pre-admit throw skips terminal settlement).
+  // No bare catch→fresh: lookup/resume failures surface; only true absence mints new.
+  const projectRoot = parsed.project ?? env.cwd;
+  const ticketProbe = await probeInstructionTicket(
+    parsed.instruction,
+    projectRoot,
+    env,
+  );
+  const probedTicketNumber = ticketNumberFromProbe(ticketProbe);
+  if (probedTicketNumber !== undefined) {
+    const summons: SameTicketSummonsMaterials = {
+      instruction: parsed.instruction,
+      instructionEmpty: parsed.instruction.trim() === "",
+      attachmentPaths: parsed.attachmentPaths,
+    };
+    const resumed = await tryResumeSameTicketSeatRun({
+      home: env.home,
+      projectRoot,
+      role: "inspector",
+      ticketNumber: probedTicketNumber,
+      summons,
+      resume: (runId, materials) =>
+        runPublicInspectorResume(
+          { runId, ...(materials === undefined ? {} : { summons: materials }) },
+          env,
+          io,
+        ),
+    });
+    if (resumed !== undefined) return resumed;
+  }
+
   let admitted: AdmittedInspectorInvocation;
   try {
-    const parsed = parseInspectorArgv(argv);
     admitted = await admitInspectorInvocation({
       home: env.home,
       principalAuthority: env.principalAuthority,
@@ -91,26 +141,12 @@ export async function runPublicInspector(
     throw error;
   }
 
-  // #635 seat self-ticket then #636 ticket+seat memory principal (before admitted mark).
-  await resolveSeatTicketBinding(admitted, env);
-  const memory = await rebindAdmittedToTicketSeatMemory({
-    admitted,
-    seat: "inspector",
-    principalAuthority: env.principalAuthority,
-  });
   await markRunAdmitted(admitted, env.principalAuthority);
 
-  // Same ticket nest already present → native host resume (not a fresh initial).
-  // Prompt is the same officer transport; only continuation kind flips (#636 / ADR 0079).
   const engineMaterial = engineSessionMaterialFromOptions({
     ...(env.engine === undefined ? {} : { engine: env.engine }),
     packageRoot: env.packageRoot,
   });
-  const continuation = {
-    kind: memory?.resumed === true ? ("resume" as const) : ("initial" as const),
-    prompt: buildInspectorTransportPrompt(admitted, engineMaterial),
-  };
-
   const turnRequest = buildInspectorTurnRequest(admitted, {
     packageRoot: env.packageRoot,
     home: env.home,
@@ -121,7 +157,10 @@ export async function runPublicInspector(
     ...(env.correlationId === undefined || env.correlationId.trim() === ""
       ? {}
       : { correlationId: env.correlationId }),
-    continuation,
+    continuation: {
+      kind: "initial",
+      prompt: buildInspectorTransportPrompt(admitted, engineMaterial),
+    },
   });
 
   return await runPostAdmissionOneShot({
@@ -129,20 +168,34 @@ export async function runPublicInspector(
     env,
     io,
     request: turnRequest,
-    adapters: inspectorAdapters(),
+    adapters: inspectorAdapters({
+      beforeDispatch: async (admittedSeat) => {
+        // #635/#637: apply pre-admit probe inside controlled-failure boundary.
+        await applyInstructionTicketProbe(admittedSeat, ticketProbe);
+      },
+    }),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }
 
-function inspectorAdapters(): PostAdmissionAdapters<AdmittedInspectorInvocation> {
+function inspectorAdapters(options?: {
+  beforeDispatch?: (
+    admitted: AdmittedInspectorInvocation,
+  ) => void | Promise<void>;
+}): PostAdmissionAdapters<AdmittedInspectorInvocation> {
   return {
-    trySettle: (admitted, authority) => trySettleInspectorTerminalResult(admitted, authority),
+    trySettle: (admitted, authority, scope) => trySettleInspectorTerminalResult(admitted, authority, scope),
     shouldPresentSettled: () => true,
+    ...(options?.beforeDispatch === undefined
+      ? {}
+      : { beforeDispatch: options.beforeDispatch }),
   };
 }
 
 /**
- * Resume a previously admitted Inspector run (#633); the session principal reopens.
+ * Resume a previously admitted Inspector run (#633 / #637); the session principal reopens.
+ * Same-ticket summons deliver this turn's instruction + frozen attachments; manual
+ * resume keeps package-envelope / caller-message semantics and birth attachments.
  */
 export async function runPublicInspectorResume(
   request: PublicResumeRequest,
@@ -157,17 +210,27 @@ export async function runPublicInspectorResume(
     request,
     env,
     io,
-    load: () =>
+    load: (effective) =>
       loadResumableInspectorRun(
-      env.home,
-      request.runId,
-      env.principalAuthority,
-    ),
-    buildTurnRequest: (admitted) =>
-      buildInspectorTurnRequest(
-      admitted,
-      resumeTurnRequestProjectionOptions(admitted, request, env),
-    ),
+        env.home,
+        effective.runId,
+        env.principalAuthority,
+      ),
+    buildTurnRequest: async (admitted, effective) => {
+      const summonsPrepared = await prepareSummonsResumeMaterials(
+        admitted.runDirectory,
+        effective.summons,
+      );
+      return buildInspectorTurnRequest(
+        admitted,
+        resumeTurnRequestProjectionOptions(
+          admitted,
+          effective,
+          env,
+          summonsPrepared,
+        ),
+      );
+    },
     adapters: inspectorAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });

package/src/public-cli/instruction-seat-run.ts

@@ -70,10 +70,11 @@ function instructionSeatAdapters() {
     trySettle: (
       admitted: AdmittedInstructionSeatInvocation,
       authority: DurablePrincipalAuthority,
+      scope?: { readonly courtAttemptId?: string },
     ) =>
       admitted.role === "gatekeeper"
-        ? trySettleGatekeeperTerminalResult(admitted, authority)
-        : trySettleNavigatorTerminalResult(admitted, authority),
+        ? trySettleGatekeeperTerminalResult(admitted, authority, scope)
+        : trySettleNavigatorTerminalResult(admitted, authority, scope),
     // Accepted receipts and failure terminals both present via shared path.
     shouldPresentSettled: () => true,
   };
@@ -88,14 +89,14 @@ export async function runPublicInstructionSeatResume(
     request,
     env,
     io,
-    load: () => loadResumableInstructionSeatRun(
+    load: (effective) => loadResumableInstructionSeatRun(
       env.home,
-      request.runId,
+      effective.runId,
       env.principalAuthority,
     ),
-    buildTurnRequest: (admitted) => buildInstructionSeatTurnRequest(
+    buildTurnRequest: (admitted, effective) => buildInstructionSeatTurnRequest(
       admitted,
-      resumeTurnRequestProjectionOptions(admitted, request, env),
+      resumeTurnRequestProjectionOptions(admitted, effective, env),
     ),
     adapters: instructionSeatAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),

package/src/public-cli/invocation.ts

@@ -24,7 +24,7 @@ import type {
   DurablePrincipal,
   DurablePrincipalAuthority,
 } from "../host-contracts.ts";
-import { readRunTicketNumber } from "../ticket-seat-memory.ts";
+import { readRunTicketNumber } from "../run-ticket-number.ts";
 import {
   loadDoctorCase,
 } from "../doctor-evidence.ts";
@@ -1004,14 +1004,20 @@ async function freezeAttachments(
 }
 
 /**
- * Read ticketNumber from a retained source run's admitted-request.json,
- * falling back to invocation.json. Sole implementation lives in ticket-seat-memory
- * (shared with officer nest discovery / auditor subject binding).
+ * Freeze summons attachments into an already-retained run (#637 same-ticket resume).
+ * Writes under attachments/summons-<key>/ so prior freeze names stay intact.
+ * Manual resume never calls this — birth attachments keep their original semantics.
  */
-export async function readTicketNumberFromSourceRun(
+export async function freezeAttachmentsIntoRun(
+  attachmentPaths: readonly string[],
   runDirectory: string,
-): Promise<number | undefined> {
-  return readRunTicketNumber(runDirectory);
+  summonsKey: string = `s-${Date.now().toString(36)}`,
+): Promise<readonly FrozenAttachment[]> {
+  if (attachmentPaths.length === 0) return [];
+  const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(runDirectory));
+  const attachmentsDirectory = join(runDirectory, "attachments", summonsKey);
+  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
+  return freezeAttachments(attachmentPaths, attachmentsDirectory);
 }
 
 function ticketAdmissionFields(
@@ -2332,7 +2338,7 @@ export async function admitNotaryInvocation(options: {
   });
   ensureRealDirectoryTree(ledgerHome, sessionDirectory);
   const ticketFields = ticketAdmissionFields(
-    await readTicketNumberFromSourceRun(sourceRun.runDirectory),
+    await readRunTicketNumber(sourceRun.runDirectory),
   );
 
   const admitted = {

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

@@ -184,12 +184,12 @@ export async function runPublicResume(
     request,
     env,
     io,
-    load: () =>
-      loadResumableJudgeRun(env.home, request.runId, env.principalAuthority),
-    buildTurnRequest: (admitted) =>
+    load: (effective) =>
+      loadResumableJudgeRun(env.home, effective.runId, env.principalAuthority),
+    buildTurnRequest: (admitted, effective) =>
       buildJudgeTurnRequest(
       admitted,
-      resumeTurnRequestProjectionOptions(admitted, request, env),
+      resumeTurnRequestProjectionOptions(admitted, effective, env),
     ),
     adapters: judgeAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),