@akagilnc/pi-workflow-roles 0.1.3452 → 0.1.3471

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

@@ -2,17 +2,23 @@
  * Public Notary Role run: admit source-run locator → shared post-admission coordinator
  * → settle Terminal result (#448 / #517). Zero caller prompt/attachment. Lifecycle is
  * the shared post-admission seam; this module keeps only Notary adapters.
+ * #637: same-ticket re-summons resume the seat's previous run (no new run).
  */
 import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
+import {
+  NotarySourceRunError,
+  resolveNotarySourceRunLocator,
+} from "../notary-source-run.ts";
 import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.ts";
-import { rebindAdmittedToTicketSeatMemory } from "../ticket-seat-memory.ts";
+import { readRunTicketNumber } from "../run-ticket-number.ts";
 import { CliUsageError } from "./cli-errors.ts";
 import {
   admitNotaryInvocation,
   buildNotaryTransportPrompt,
   type AdmittedNotaryInvocation,
-  type ParseNotaryArgvResult
+  type ParseNotaryArgvResult,
 } from "./invocation.ts";
+import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.ts";
 import {
   runPostAdmissionOneShot,
   type PostAdmissionAdapters,
@@ -24,6 +30,7 @@ import {
   loadResumableNotaryRun,
   markRunAdmitted,
   type PublicResumeRequest,
+  type SameTicketSummonsMaterials,
 } from "./run-lifecycle.ts";
 import {
   presentStructuralRejection,
@@ -72,9 +79,59 @@ export async function runPublicNotary(
   admitted?: AdmittedNotaryInvocation;
   terminal?: TerminalResult;
 }> {
+  let parsed: ParseNotaryArgvResult;
+  try {
+    parsed = parseNotaryArgv(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  // #637: same ticket → resume prior notary run with this summons' source-run pointer.
+  // Source-run structural failures stay usage rejections; lookup/resume failures surface
+  // (no bare catch→fresh). Only true absence of a prior run mints new.
+  const projectRoot = parsed.project ?? env.cwd;
+  let source;
+  try {
+    source = await resolveNotarySourceRunLocator({
+      projectRoot,
+      sourceRun: parsed.sourceRun,
+      home: env.home,
+    });
+  } catch (error) {
+    if (error instanceof NotarySourceRunError) {
+      presentStructuralRejection(new CliUsageError(error.message, { cause: error }), io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+  const ticketNumber = await readRunTicketNumber(source.runDirectory);
+  if (ticketNumber !== undefined) {
+    const summons: SameTicketSummonsMaterials = {
+      sourceRunPath: source.runDirectory,
+      sourceRun: source,
+    };
+    const resumed = await tryResumeSameTicketSeatRun({
+      home: env.home,
+      projectRoot,
+      role: "notary",
+      ticketNumber,
+      summons,
+      resume: (runId, materials) =>
+        runPublicNotaryResume(
+          { runId, ...(materials === undefined ? {} : { summons: materials }) },
+          env,
+          io,
+        ),
+    });
+    if (resumed !== undefined) return resumed;
+  }
+
   let admitted: AdmittedNotaryInvocation;
   try {
-    const parsed = parseNotaryArgv(argv);
     admitted = await admitNotaryInvocation({
       home: env.home,
       principalAuthority: env.principalAuthority,
@@ -93,27 +150,12 @@ export async function runPublicNotary(
     throw error;
   }
 
-  // #636: ticket from source-run → continue ticket+seat memory principal across runs.
-  // Rebind before admitted mark so run-state session paths name the memory principal.
-  // Existing nest → continuation.kind=resume so real hosts reopen native volume (Grok
-  // session/load; Pi/Grok hostTransition path handoff). Same-ticket rebind alone is not resume.
-  const memory = await rebindAdmittedToTicketSeatMemory({
-    admitted,
-    seat: "notary",
-    principalAuthority: env.principalAuthority,
-  });
   await markRunAdmitted(admitted, env.principalAuthority);
 
   const engineMaterial = engineSessionMaterialFromOptions({
     ...(env.engine === undefined ? {} : { engine: env.engine }),
     packageRoot: env.packageRoot,
   });
-  // Prompt is the same officer transport; only continuation kind flips (#636 / ADR 0079).
-  const continuation = {
-    kind: memory?.resumed === true ? ("resume" as const) : ("initial" as const),
-    prompt: buildNotaryTransportPrompt(admitted, engineMaterial),
-  };
-
   const turnRequest = buildNotaryTurnRequest(admitted, {
     packageRoot: env.packageRoot,
     home: env.home,
@@ -124,7 +166,10 @@ export async function runPublicNotary(
     ...(env.correlationId === undefined || env.correlationId.trim() === ""
       ? {}
       : { correlationId: env.correlationId }),
-    continuation,
+    continuation: {
+      kind: "initial",
+      prompt: buildNotaryTransportPrompt(admitted, engineMaterial),
+    },
   });
 
   return await runPostAdmissionOneShot({
@@ -139,15 +184,16 @@ export async function runPublicNotary(
 
 function notaryAdapters(): PostAdmissionAdapters<AdmittedNotaryInvocation> {
   return {
-    trySettle: (admitted, authority) => trySettleNotaryTerminalResult(admitted, authority),
+    trySettle: (admitted, authority, scope) => trySettleNotaryTerminalResult(admitted, authority, scope),
     // Accepted receipts and failure terminals both present via shared path.
     shouldPresentSettled: () => true,
   };
 }
 
 /**
- * Resume a previously admitted Notary run (#633). Source-run locator restores
- * from the durable admitted request (never re-resolved); the session principal reopens.
+ * Resume a previously admitted Notary run (#633 / #637). Manual resume restores
+ * source-run from the durable admitted request. Same-ticket re-summons deliver
+ * this turn's source-run activation pointer while reopening the same session.
  */
 export async function runPublicNotaryResume(
   request: PublicResumeRequest,
@@ -162,22 +208,37 @@ export async function runPublicNotaryResume(
     request,
     env,
     io,
-    load: () => {
-      if (request.message !== undefined) {
+    load: async (effective) => {
+      if (effective.message !== undefined) {
         throw new CliUsageError(
           "notary rejects caller prompt/instruction; only zero caller-prompt continuation admitted",
         );
       }
-      return loadResumableNotaryRun(
+      const loaded = await loadResumableNotaryRun(
         env.home,
-        request.runId,
+        effective.runId,
         env.principalAuthority,
       );
+      const summons = effective.summons;
+      if (
+        summons?.sourceRunPath !== undefined &&
+        summons.sourceRun !== undefined
+      ) {
+        return {
+          admitted: {
+            ...loaded.admitted,
+            sourceRunPath: summons.sourceRunPath,
+            sourceRun: summons.sourceRun,
+          },
+        };
+      }
+      return loaded;
     },
-    buildTurnRequest: (admitted) => buildNotaryTurnRequest(
-      admitted,
-      resumeTurnRequestProjectionOptions(admitted, request, env),
-    ),
+    buildTurnRequest: (admitted, effective) =>
+      buildNotaryTurnRequest(
+        admitted,
+        resumeTurnRequestProjectionOptions(admitted, effective, env),
+      ),
     adapters: notaryAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });