@akagilnc/pi-workflow-roles 0.1.3565 → 0.1.3621

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

@@ -0,0 +1,118 @@
+import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.js";
+import { CliUsageError } from "./cli-errors.js";
+import { admitJudgeInvocation, buildJudgeTransportPrompt, } from "./invocation.js";
+import { resolveSeatTicketBinding } from "./seat-ticket-binding.js";
+import { loadResumableJudgeRun, markRunAdmitted, buildResumeContinuationPrompt, } from "./run-lifecycle.js";
+import { presentStructuralRejection, readEngineDetourInfrastructureFailure, trySettleJudgeTerminalResult, } from "./settlement.js";
+import { projectRoleTurnRequest, } from "./turn-request.js";
+import { runPostAdmissionResumable, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
+/** Project admitted invocation onto the host-neutral turn request. */
+export function buildJudgeTurnRequest(admitted, options) {
+    return projectRoleTurnRequest(admitted, { activation: { role: "judge" } }, options);
+}
+function judgeAdapters() {
+    return {
+        trySettle: (admitted, authority) => trySettleJudgeTerminalResult(admitted, authority),
+        resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
+            const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
+            return (result.knownFailure ??
+                (infrastructureFailure === undefined
+                    ? undefined
+                    : {
+                        cause: infrastructureFailure.cause,
+                        diagnostic: infrastructureFailure.diagnostic,
+                        ...(infrastructureFailure.identity === undefined
+                            ? {}
+                            : { identity: infrastructureFailure.identity }),
+                    }));
+        },
+    };
+}
+export async function runPublicJudge(argv, env, io, parseJudgeArgv) {
+    let admitted;
+    try {
+        const parsed = parseJudgeArgv(argv);
+        admitted = await admitJudgeInvocation({
+            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 }),
+        });
+    }
+    catch (error) {
+        if (error instanceof CliUsageError) {
+            presentStructuralRejection(error, io);
+            return { exitCode: 2 };
+        }
+        throw error;
+    }
+    await markRunAdmitted(admitted, env.principalAuthority);
+    return await runPostAdmissionResumable({
+        admitted,
+        env,
+        io,
+        buildInitialRequest: () => buildJudgeTurnRequest(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 }),
+            ...(admitted.correlationId === undefined && env.correlationId === undefined
+                ? {}
+                : { correlationId: admitted.correlationId ?? env.correlationId }),
+            continuation: {
+                kind: "initial",
+                prompt: buildJudgeTransportPrompt(admitted, engineSessionMaterialFromOptions({
+                    ...(env.engine === undefined ? {} : { engine: env.engine }),
+                    packageRoot: env.packageRoot,
+                })),
+            },
+        }),
+        buildResumeRequest: () => buildJudgeTurnRequest(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 }),
+            ...(admitted.correlationId === undefined && env.correlationId === undefined
+                ? {}
+                : { correlationId: admitted.correlationId ?? env.correlationId }),
+            continuation: {
+                kind: "resume",
+                prompt: buildResumeContinuationPrompt({
+                    packageRoot: env.packageRoot,
+                    ...(env.engine === undefined ? {} : { engine: env.engine }),
+                }),
+            },
+        }),
+        adapters: {
+            ...judgeAdapters(),
+            beforeDispatch: async (admittedSeat) => {
+                await resolveSeatTicketBinding(admittedSeat, env);
+            },
+        },
+        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+    });
+}
+/**
+ * Resume a previously admitted Role run after a typed HTTP 429 interruption.
+ * Restores role/project/instruction/attachments/session identity; model override
+ * is temporary for this invocation only.
+ */
+export async function runPublicResume(request, env, io) {
+    return await runPostAdmissionSeatResume({
+        request,
+        env,
+        io,
+        load: (effective) => loadResumableJudgeRun(env.home, effective.runId, env.principalAuthority),
+        buildTurnRequest: (admitted, effective) => buildJudgeTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env)),
+        adapters: judgeAdapters(),
+        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+    });
+}

package/dist/public-cli/load-production-acp-host.js

@@ -0,0 +1,40 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * Deferred loader for the packaged generic ACP RoleTurnHost factory.
+ *
+ * Public ak-role bin must not statically value-import the production host (or its
+ * role-runtime / pi-coding-agent edges). Specifier is runtime-constructed so
+ * esbuild leaves this import external (ADR 0052 discovery stays peer-free).
+ *
+ * Host selection is a description-table lookup: the row for the seat's host key
+ * is the factory input. There is no host-name fork here.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { lookupHostDescription } from "../host-descriptions.js";
+/**
+ * Resolve the production ACP host factory for one registered host key without a
+ * static graph edge into the public CLI bundle.
+ */
+export async function loadProductionAcpHostFactory(packageRoot, host) {
+    const description = lookupHostDescription(host);
+    if (description === undefined) {
+        throw new Error(`unregistered host: ${host}`);
+    }
+    const built = join(packageRoot, "dist/acp-host/production-host.js");
+    const source = join(packageRoot, "src/acp-host/production-host.ts");
+    // Prefer the built artifact (plain node); fall back to source under tsx tests.
+    const target = existsSync(built) ? built : source;
+    const href = pathToFileURL(target).href;
+    const mod = (await import(__rewriteRelativeImportExtension(href)));
+    const create = mod.createProductionAcpRoleTurnHost;
+    return (options) => create({ ...options, description });
+}