@akagilnc/pi-workflow-roles 0.1.3572 → 0.1.3621

package/dist/public-cli/notary-run.js

@@ -0,0 +1,161 @@
+import { NotarySourceRunError, resolveNotarySourceRunLocator, } from "../notary-source-run.js";
+import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.js";
+import { readRunTicketNumber } from "../run-ticket-number.js";
+import { CliUsageError } from "./cli-errors.js";
+import { admitNotaryInvocation, buildNotaryTransportPrompt, } from "./invocation.js";
+import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
+import { runPostAdmissionOneShot, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
+import { loadResumableNotaryRun, markRunAdmitted, } from "./run-lifecycle.js";
+import { presentStructuralRejection, trySettleNotaryTerminalResult, } from "./settlement.js";
+import { projectRoleTurnRequest, } from "./turn-request.js";
+/** Project admitted invocation onto the host-neutral turn request. */
+export function buildNotaryTurnRequest(admitted, options) {
+    return projectRoleTurnRequest(admitted, {
+        activation: {
+            role: "notary",
+            sourceRun: admitted.sourceRunPath,
+            // Ticket from source-run admitted form rides activation → flag → role read surface (#635).
+            ...(admitted.ticketNumber === undefined
+                ? {}
+                : { ticketNumber: admitted.ticketNumber }),
+        },
+    }, options);
+}
+export async function runPublicNotary(argv, env, io, parseNotaryArgv) {
+    let parsed;
+    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 = {
+            sourceRunPath: source.runDirectory,
+            sourceRun: source,
+        };
+        const resumed = await tryResumeSameTicketSeatRun({
+            home: env.home,
+            projectRoot,
+            role: "notary",
+            ticketNumber,
+            freshSummons: env.freshSummons,
+            summons,
+            resume: (runId, materials) => runPublicNotaryResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, env, io),
+        });
+        if (resumed !== undefined)
+            return resumed;
+    }
+    let admitted;
+    try {
+        admitted = await admitNotaryInvocation({
+            home: env.home,
+            principalAuthority: env.principalAuthority,
+            cwd: env.cwd,
+            sourceRun: parsed.sourceRun,
+            ...(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);
+    const engineMaterial = engineSessionMaterialFromOptions({
+        ...(env.engine === undefined ? {} : { engine: env.engine }),
+        packageRoot: env.packageRoot,
+    });
+    const turnRequest = buildNotaryTurnRequest(admitted, {
+        packageRoot: env.packageRoot,
+        home: env.home,
+        agentDir: env.agentDir,
+        ...(env.model === undefined ? {} : { model: env.model }),
+        ...(env.engine === undefined ? {} : { engine: env.engine }),
+        ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
+        ...(env.correlationId === undefined || env.correlationId.trim() === ""
+            ? {}
+            : { correlationId: env.correlationId }),
+        continuation: {
+            kind: "initial",
+            prompt: buildNotaryTransportPrompt(admitted, engineMaterial),
+        },
+    });
+    return await runPostAdmissionOneShot({
+        admitted,
+        env,
+        io,
+        request: turnRequest,
+        adapters: notaryAdapters(),
+        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+    });
+}
+function notaryAdapters() {
+    return {
+        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 / #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, env, io) {
+    return await runPostAdmissionSeatResume({
+        request,
+        env,
+        io,
+        load: async (effective) => {
+            if (effective.message !== undefined) {
+                throw new CliUsageError("notary rejects caller prompt/instruction; only zero caller-prompt continuation admitted");
+            }
+            const loaded = await loadResumableNotaryRun(env.home, 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, effective) => buildNotaryTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env)),
+        adapters: notaryAdapters(),
+        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+    });
+}