@akagilnc/pi-workflow-roles 0.1.4800 → 0.1.4870

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

@@ -1,174 +0,0 @@
-import { NotarySourceRunError, resolveNotarySourceRunLocator, } from "../notary-source-run.js";
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.js";
-import { CliUsageError } from "./cli-errors.js";
-import { admitNotaryInvocation, buildNotaryTransportPrompt, } from "./invocation.js";
-import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
-import { prepareSummonsResumeMaterials, 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;
-    }
-    // #747: officer resume key is this parent source-run path (not ticket number).
-    // #753/#879: gate re-ask and verbatim submission body share summons.instruction
-    // (reask wins when both present; no parallel stack). Binding stays sourceRunPath.
-    {
-        const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
-        const summons = {
-            sourceRunPath: source.runDirectory,
-            sourceRun: source,
-            ...(resumeInstruction === undefined
-                ? {}
-                : { instruction: resumeInstruction, instructionEmpty: false }),
-        };
-        const resumed = await tryResumeSameTicketSeatRun({
-            home: env.home,
-            projectRoot,
-            role: "notary",
-            parentRunPath: source.runDirectory,
-            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({
-        ...pickEngineAxis(env),
-        packageRoot: env.packageRoot,
-    });
-    const turnRequest = buildNotaryTurnRequest(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",
-            // #879: gate path first mint carries parent payload as dialogue content;
-            // external zero-prompt kickoff unchanged when no body/reask.
-            prompt: (env.reviewReask ?? env.gateReviewInstruction)
-                ?? 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) => {
-            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: async (admitted, effective) => {
-            // #755: review continuation is plain dialogue / resume envelope — no
-            //「重新读」candidate line, no engine handbook packaging.
-            // #753: non-three-state re-ask rides as summons.instruction (人话重问).
-            const summonsPrepared = effective.summons === undefined
-                ? undefined
-                : await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
-            return buildNotaryTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared));
-        },
-        adapters: notaryAdapters(),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}

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

@@ -1,339 +0,0 @@
-/**
- * Public Reviewer Role run: admit → post-admission coordinator → settle Terminal result (#917 / #517).
- * Package-owned ak-cross-m-review method is forced; users never submit
- * extra packets. Controlled-failure settlement reuses #107.
- * #526: execution via RoleTurnHost; argv is Pi adapter internal.
- */
-import { resolve } from "node:path";
-import { appendEngineSessionMaterial, engineSessionMaterialFromOptions, pickEngineAxis, } from "../package-resources/engine-material.js";
-import { loadPackagedMethodSkillMaterial, resolvePackagedMethodSkillPath, } from "../package-resources/method-skill.js";
-import { CliUsageError } from "./cli-errors.js";
-import { admitReviewerInvocation, buildReviewerTransportPrompt, } from "./invocation.js";
-import { loadResumableReviewerRun, markRunAdmitted, RESUME_TRANSPORT_ENVELOPE, } from "./run-lifecycle.js";
-import { presentStructuralRejection, readEngineDetourInfrastructureFailure, trySettleReviewerTerminalResult, } from "./settlement.js";
-import { formatTerminalResult, isLawfulTypedTerminalOutcome, } from "./terminal.js";
-import { projectRoleTurnRequest, } from "./turn-request.js";
-import { presentControlledFailure, resolveResumeMethodMaterialAdapters, runPostAdmissionResumable, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
-function reviewerMethods(packageRoot) {
-    return [{ kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot, "ak-cross-m-review") }];
-}
-/**
- * All Reviewer turns (explicit --lens, dual-lens child, resume) execute in a
- * fresh worktree of the source tree's current HEAD (#946 统一新副本). Dual-lens
- * summon already injects executionCwd; only mint when absent. Cleanup failure
- * is diagnostic only and does not flip the exit code. Mint failure propagates
- * so the caller can settle a controlled failure against the admitted run.
- */
-async function runReviewerTurnInFreshCopy(env, projectRoot, io, body) {
-    if (env.executionCwd !== undefined) {
-        return body(env);
-    }
-    const { withEphemeralReviewerWorktree } = await import("../public-role-summons.js");
-    return await withEphemeralReviewerWorktree({
-        projectRoot,
-        onCleanupDiagnostic: (diagnostic) => {
-            io.stderr(`${diagnostic}\n`);
-        },
-        run: (executionCwd) => body({ ...env, executionCwd }),
-    });
-}
-/** Project admitted Reviewer invocation onto the host-neutral turn request. */
-export function buildReviewerTurnRequest(admitted, options) {
-    return projectRoleTurnRequest(admitted, {
-        activation: {
-            role: "reviewer",
-            baseRevision: admitted.baseRevision,
-            lens: admitted.lens,
-            authorityRefs: admitted.authorityRefs,
-            ...(admitted.ticketNumber === undefined ? {} : { ticketNumber: admitted.ticketNumber }),
-        },
-        methods: reviewerMethods(options.packageRoot),
-    }, options);
-}
-function reviewerAdapters(packageRoot, methodMaterial) {
-    return {
-        trySettle: (admitted, authority, scope) => methodMaterial === undefined
-            ? Promise.resolve(undefined)
-            : trySettleReviewerTerminalResult(admitted, authority, {
-                methodProvenance: methodMaterial.provenance,
-                methodSkillPath: methodMaterial.skillPath,
-                methodSkillConfiguredPath: resolvePackagedMethodSkillPath(packageRoot, "ak-cross-m-review"),
-            }, scope),
-        resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
-            const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
-            return infrastructureFailure === undefined
-                ? result.knownFailure
-                : {
-                    ...(infrastructureFailure.cause === undefined
-                        ? {}
-                        : { cause: infrastructureFailure.cause }),
-                    diagnostic: infrastructureFailure.diagnostic,
-                    ...(infrastructureFailure.identity === undefined
-                        ? {}
-                        : { identity: infrastructureFailure.identity }),
-                };
-        },
-    };
-}
-async function loadReviewerMethodMaterial(packageRoot) {
-    return await loadPackagedMethodSkillMaterial(packageRoot, "ak-cross-m-review");
-}
-/** Continue the existing method turn; frozen axes remain on typed activation fields. */
-function reviewerResumePrompt(env, message) {
-    const lines = [RESUME_TRANSPORT_ENVELOPE];
-    if (message !== undefined)
-        lines.push("", message);
-    return appendEngineSessionMaterial(lines, engineSessionMaterialFromOptions({
-        ...pickEngineAxis(env),
-        packageRoot: env.packageRoot,
-    })).join("\n");
-}
-export async function runPublicReviewer(argv, env, io, parseReviewerArgv) {
-    let parsed;
-    try {
-        parsed = parseReviewerArgv(argv);
-    }
-    catch (error) {
-        if (error instanceof CliUsageError) {
-            presentStructuralRejection(error, io);
-            return { exitCode: 2 };
-        }
-        throw error;
-    }
-    // Omitted public lens is the parallel two-axis branch mark; never admitted as a parent run.
-    // Each leg reuses this call's public argv and only adds --lens (#946 / 10a).
-    if (parsed.lens === undefined) {
-        const { summonParallelReviewerLenses } = await import("../public-role-summons.js");
-        const children = await summonParallelReviewerLenses({
-            argv,
-            // Replay argv under the same cwd the single-axis entry would see (10a).
-            // Do not substitute the resolved project path — relative --project must
-            // not be re-resolved against a shifted cwd.
-            cwd: env.cwd,
-            projectRoot: resolve(parsed.project ?? env.cwd),
-            // Typed base from the public parse — precheck only; child argv stays verbatim.
-            baseRevision: parsed.baseRevision,
-            home: env.home,
-            agentDir: env.agentDir,
-            ...(env.credentials === undefined ? {} : { credentials: env.credentials }),
-            ...(env.model === undefined ? {} : { model: env.model }),
-            ...(env.host === undefined ? {} : { host: env.host }),
-            ...(env.engine === undefined ? {} : { engine: env.engine }),
-            ...(env.engineModel === undefined ? {} : { engineModel: env.engineModel }),
-            packageRoot: env.packageRoot,
-            ...(env.signal === undefined ? {} : { signal: env.signal }),
-            ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
-            roleTurnHost: env.roleTurnHost,
-            ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
-            principalAuthority: env.principalAuthority,
-            ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-        });
-        const childResults = [children.completeness, children.correctness];
-        const terminals = childResults
-            .map((child) => child.terminal)
-            .filter((terminal) => terminal !== undefined);
-        // ADR 0052 / terminal.ts: lawful typed child terminals (accepted / no_receipt /
-        // audit_escalation) are not batch failures. Child exitCode remains the live
-        // surface for seal/infrastructure overlays that keep the original Terminal.
-        // failedChildren counts only non-lawful/missing child Terminals; seal overlays
-        // that flip exitCode while keeping lawful Terminals are a separate identity.
-        const failedChildren = childResults.filter((child) => child.terminal === undefined
-            || !isLawfulTypedTerminalOutcome(child.terminal.roleOutcome)).length;
-        const overlayExit = childResults.some((child) => child.exitCode !== 0);
-        const failed = failedChildren > 0 || overlayExit;
-        const overlayDiagnostics = [...new Set(childResults
-                .map((child) => child.stderr)
-                .filter((text) => typeof text === "string" && text !== ""))];
-        const terminal = {
-            batch: "reviewer",
-            roleOutcome: failed
-                ? {
-                    kind: "failure",
-                    role: "reviewer",
-                    diagnostic: failedChildren > 0
-                        ? "Reviewer batch child failure"
-                        : (overlayDiagnostics[0] ?? "Reviewer batch infrastructure failure"),
-                    decisiveFacts: { failedChildren },
-                    payloads: terminals,
-                }
-                : { kind: "accepted", role: "reviewer", payloads: terminals },
-            reviewerChildren: {
-                ...(children.completeness.terminal === undefined ? {} : { completeness: children.completeness.terminal }),
-                ...(children.correctness.terminal === undefined ? {} : { correctness: children.correctness.terminal }),
-            },
-            reviewerChildOutcomes: {
-                completeness: { exitCode: children.completeness.exitCode, ...(children.completeness.stderr === undefined ? {} : { stderr: children.completeness.stderr }) },
-                correctness: { exitCode: children.correctness.exitCode, ...(children.correctness.stderr === undefined ? {} : { stderr: children.correctness.stderr }) },
-            },
-            // Batch has no parent run and no own attendance; no-advice is affirmative
-            // only (navigator-attendance.ts). Children carry their own navigator facts.
-            navigator: {
-                disposition: "unavailable",
-                source: "unknown",
-                reason: "Reviewer batch has no parent-run Navigator attendance",
-            },
-            artifacts: terminals.flatMap((item) => item.artifacts),
-        };
-        io.stdout(formatTerminalResult(terminal));
-        return { exitCode: failed ? 1 : 0, terminal };
-    }
-    let admitted;
-    try {
-        admitted = await admitReviewerInvocation({
-            home: env.home,
-            principalAuthority: env.principalAuthority,
-            cwd: env.cwd,
-            instruction: parsed.instruction,
-            attachmentPaths: parsed.attachmentPaths,
-            baseRevision: parsed.baseRevision,
-            lens: parsed.lens,
-            authorityRefs: parsed.authorityRefs,
-            ...(parsed.project === undefined ? {} : { project: parsed.project }),
-            ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
-            ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
-            ...(env.model === undefined ? {} : { model: env.model }),
-        });
-    }
-    catch (error) {
-        if (error instanceof CliUsageError) {
-            presentStructuralRejection(error, io);
-            return { exitCode: 2 };
-        }
-        throw error;
-    }
-    await markRunAdmitted(admitted, env.principalAuthority);
-    let methodMaterial;
-    try {
-        methodMaterial = await loadReviewerMethodMaterial(env.packageRoot);
-    }
-    catch (error) {
-        return (await presentControlledFailure(admitted, {
-            timedOut: false,
-            code: null,
-            stderr: "",
-            thrown: error,
-        }, reviewerAdapters(env.packageRoot), env.principalAuthority, io));
-    }
-    // Fresh copy for this call (explicit --lens or dual-lens child with pre-set cwd).
-    // Durable projectRoot stays the caller project; only the host turn uses the sandbox.
-    try {
-        return await runReviewerTurnInFreshCopy(env, admitted.projectRoot, io, async (sandboxedEnv) => await runPostAdmissionResumable({
-            admitted,
-            env: sandboxedEnv,
-            io,
-            buildInitialRequest: () => buildReviewerTurnRequest(admitted, {
-                packageRoot: sandboxedEnv.packageRoot,
-                home: sandboxedEnv.home,
-                agentDir: sandboxedEnv.agentDir,
-                ...(sandboxedEnv.model === undefined ? {} : { model: sandboxedEnv.model }),
-                ...pickEngineAxis(sandboxedEnv),
-                ...(sandboxedEnv.timeoutMs === undefined ? {} : { timeoutMs: sandboxedEnv.timeoutMs }),
-                ...(admitted.correlationId === undefined && sandboxedEnv.correlationId === undefined
-                    ? {}
-                    : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId }),
-                // Ephemeral worktree cwd; durable projectRoot stays on admitted caller project.
-                ...(sandboxedEnv.executionCwd === undefined ? {} : { cwd: sandboxedEnv.executionCwd }),
-                continuation: {
-                    kind: "initial",
-                    prompt: buildReviewerTransportPrompt(admitted, engineSessionMaterialFromOptions({
-                        ...pickEngineAxis(sandboxedEnv),
-                        packageRoot: sandboxedEnv.packageRoot,
-                    })),
-                },
-            }),
-            buildResumeRequest: () => buildReviewerTurnRequest(admitted, {
-                packageRoot: sandboxedEnv.packageRoot,
-                home: sandboxedEnv.home,
-                agentDir: sandboxedEnv.agentDir,
-                ...(sandboxedEnv.model === undefined ? {} : { model: sandboxedEnv.model }),
-                ...pickEngineAxis(sandboxedEnv),
-                ...(sandboxedEnv.timeoutMs === undefined ? {} : { timeoutMs: sandboxedEnv.timeoutMs }),
-                ...(admitted.correlationId === undefined && sandboxedEnv.correlationId === undefined
-                    ? {}
-                    : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId }),
-                // In-batch auto-resume keeps the same call's sandbox (dual-lens or single).
-                ...(sandboxedEnv.executionCwd === undefined ? {} : { cwd: sandboxedEnv.executionCwd }),
-                continuation: {
-                    kind: "resume",
-                    prompt: reviewerResumePrompt(sandboxedEnv),
-                },
-            }),
-            adapters: reviewerAdapters(sandboxedEnv.packageRoot, methodMaterial),
-            ...(sandboxedEnv.engine === undefined ? {} : { effectiveEngine: sandboxedEnv.engine }),
-        }));
-    }
-    catch (error) {
-        return (await presentControlledFailure(admitted, {
-            timedOut: false,
-            code: null,
-            stderr: "",
-            thrown: error,
-        }, reviewerAdapters(env.packageRoot, methodMaterial), env.principalAuthority, io));
-    }
-}
-/**
- * Resume a previously admitted Reviewer Role run after a typed HTTP 429.
- * Restores task/base/session identity; model override is temporary.
- * Execution always uses a fresh worktree of the source tree at resume time
- * (#946 统一新副本 / 10a) — no old worktree, no ownership record.
- * Fresh-copy mint reuses the coordinator's single pre-lease load via
- * afterAdmittedPrepare; does not pre-load outside the coordinator.
- */
-export async function runPublicReviewerResume(request, env, io) {
-    // Call-local cell: afterAdmittedPrepare writes executionCwd; buildTurnRequest reads it.
-    // Keeps the single-load coordinator contract — no preliminary load outside.
-    const sandbox = {
-        ...(env.executionCwd === undefined ? {} : { executionCwd: env.executionCwd }),
-    };
-    return await runPostAdmissionSeatResume({
-        request,
-        env,
-        io,
-        load: (effective) => loadResumableReviewerRun(env.home, effective.runId, env.principalAuthority),
-        buildTurnRequest: (admitted, effective) => {
-            const activeEnv = sandbox.executionCwd === undefined
-                ? env
-                : { ...env, executionCwd: sandbox.executionCwd };
-            const base = resumeTurnRequestProjectionOptions(admitted, effective, activeEnv);
-            return buildReviewerTurnRequest(admitted, {
-                ...base,
-                // Fresh copy at resume time; durable projectRoot unchanged.
-                ...(sandbox.executionCwd === undefined ? {} : { cwd: sandbox.executionCwd }),
-                continuation: {
-                    kind: "resume",
-                    prompt: effective.message ?? "",
-                },
-            });
-        },
-        adapters: reviewerAdapters(env.packageRoot),
-        afterAdmittedLoad: async (admitted) => {
-            return resolveResumeMethodMaterialAdapters({
-                admitted,
-                authority: env.principalAuthority,
-                io,
-                loadMaterial: () => loadReviewerMethodMaterial(env.packageRoot),
-                adaptersWith: (material) => reviewerAdapters(env.packageRoot, material),
-                emptyAdapters: reviewerAdapters(env.packageRoot),
-            });
-        },
-        afterAdmittedPrepare: async (admitted) => {
-            // Already sandboxed (in-batch auto-resume path) — nothing to mint.
-            if (sandbox.executionCwd !== undefined) {
-                return { env: { ...env, executionCwd: sandbox.executionCwd } };
-            }
-            const { openEphemeralReviewerWorktree } = await import("../public-role-summons.js");
-            const opened = await openEphemeralReviewerWorktree({
-                projectRoot: admitted.projectRoot,
-                onCleanupDiagnostic: (diagnostic) => {
-                    io.stderr(`${diagnostic}\n`);
-                },
-            });
-            sandbox.executionCwd = opened.executionCwd;
-            return {
-                env: { ...env, executionCwd: opened.executionCwd },
-                cleanup: opened.close,
-            };
-        },
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}