@agentworkforce/workload-router 0.5.0 → 0.5.4

package/dist/index.js

@@ -1,7 +1,4 @@
-import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { resolve as resolvePath } from 'node:path';
-import { frontendImplementer, codeReviewer, architecturePlanner, requirementsAnalyst, debuggerPersona, securityReviewer, technicalWriter, verifierPersona, testStrategist, tddGuard, flakeHunter, opencodeWorkflowSpecialist, npmProvenancePublisher, cloudSandboxInfra, sageSlackEgressMigrator, sageProactiveRewirer, cloudSlackProxyGuard, agentRelayE2eConductor, capabilityDiscoverer, posthogAgent, personaMaker, antiSlopAuditor } from './generated/personas.js';
+import { frontendImplementer, codeReviewer, architecturePlanner, requirementsAnalyst, debuggerPersona, securityReviewer, technicalWriter, verifierPersona, testStrategist, tddGuard, flakeHunter, opencodeWorkflowSpecialist, npmProvenancePublisher, cloudSandboxInfra, sageSlackEgressMigrator, sageProactiveRewirer, cloudSlackProxyGuard, agentRelayE2eConductor, capabilityDiscoverer, npmPackageBundlerGuard, posthogAgent, personaMaker, antiSlopAuditor, apiContractReviewer, dockerStackWrangler, e2eValidator, integrationTestAuthor, agentRelayWorkflow, relayOrchestrator } from './generated/personas.js';
 import defaultRoutingProfileJson from '../routing-profiles/default.json' with { type: 'json' };
 export const HARNESS_VALUES = ['opencode', 'codex', 'claude'];
 export const PERSONA_TIERS = ['best', 'best-value', 'minimum'];
@@ -36,9 +33,16 @@ export const PERSONA_INTENTS = [
     'cloud-slack-proxy-guard',
     'sage-cloud-e2e-conduction',
     'capability-discovery',
+    'npm-package-compat',
     'posthog',
     'persona-authoring',
-    'slop-audit'
+    'agent-relay-workflow',
+    'slop-audit',
+    'api-contract-review',
+    'local-stack-orchestration',
+    'e2e-validation',
+    'write-integration-tests',
+    'relay-orchestrator'
 ];
 export const PERMISSION_MODES = [
     'default',
@@ -68,24 +72,6 @@ export const HARNESS_SKILL_TARGETS = {
     codex: { asFlag: 'codex', dir: '.agents/skills' },
     opencode: { asFlag: 'opencode', dir: '.skills' }
 };
-export class PersonaExecutionError extends Error {
-    result;
-    cause;
-    constructor(message, result, cause) {
-        super(message, cause === undefined ? undefined : { cause });
-        this.name = 'PersonaExecutionError';
-        this.result = result;
-        this.cause = cause;
-    }
-}
-class CapturedCommandError extends Error {
-    capture;
-    constructor(message, capture) {
-        super(message);
-        this.name = 'CapturedCommandError';
-        this.capture = capture;
-    }
-}
 const PRPM_URL_RE = /^https?:\/\/prpm\.dev\/packages\/([^/\s?#]+)\/([^/\s?#]+)\/?(?:[?#].*)?$/i;
 const PRPM_BARE_REF_RE = /^([^/\s]+)\/([^/\s]+)$/;
 function lastSegment(ref) {
@@ -241,7 +227,7 @@ export function materializeSkills(skills, harness, options = {}) {
         const installedDir = installRoot !== undefined ? `${installRoot}/${repoRelativeDir}` : repoRelativeDir;
         // When the plan stages into `installRoot`, cleanup targets the whole
         // session dir (handled at plan level in buildCleanupArtifacts). Leave
-        // per-skill cleanupPaths empty so Mode B callers running individual
+        // per-skill cleanupPaths empty so callers running individual
         // install.cleanupPaths don't accidentally remove unrelated things.
         const cleanupPaths = installRoot !== undefined
             ? Object.freeze([])
@@ -381,55 +367,6 @@ function buildCleanupArtifacts(plan) {
         cleanupCommandString
     };
 }
-function buildExecutionTask(systemPrompt, task, inputs) {
-    const sections = [`System Instructions:\n${systemPrompt.trim()}`, `Task:\n${task.trim()}`];
-    if (inputs && Object.keys(inputs).length > 0) {
-        sections.push(`Additional Inputs (JSON):\n${JSON.stringify(inputs, null, 2)}`);
-    }
-    return sections.join('\n\n');
-}
-function hash8(value) {
-    return createHash('sha256').update(value).digest('hex').slice(0, 8);
-}
-function sanitizeExecutionName(value) {
-    const sanitized = value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9_.-]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    return sanitized || `persona-${hash8(value)}`;
-}
-function createDeferred() {
-    let settled = false;
-    let resolveFn;
-    let rejectFn;
-    const promise = new Promise((resolve, reject) => {
-        resolveFn = (value) => {
-            settled = true;
-            resolve(value);
-        };
-        rejectFn = (reason) => {
-            settled = true;
-            reject(reason);
-        };
-    });
-    return {
-        promise,
-        resolve: resolveFn,
-        reject: rejectFn,
-        get settled() {
-            return settled;
-        }
-    };
-}
-function createAbortError(message) {
-    const error = new Error(message);
-    error.name = 'AbortError';
-    return error;
-}
-function isTimeoutError(message) {
-    return typeof message === 'string' && /timed out/i.test(message);
-}
 function deepFreeze(value) {
     if (value === null || value === undefined || typeof value !== 'object') {
         return value;
@@ -445,177 +382,6 @@ function deepFreeze(value) {
     }
     return Object.freeze(value);
 }
-function linkAbortSignal(signal, controller) {
-    if (!signal) {
-        return () => { };
-    }
-    if (signal.aborted) {
-        controller.abort(signal.reason);
-        return () => { };
-    }
-    const onAbort = () => controller.abort(signal.reason);
-    signal.addEventListener('abort', onAbort, { once: true });
-    return () => signal.removeEventListener('abort', onAbort);
-}
-async function runCapturedCommand(options) {
-    const { command, args, cwd, env, timeoutMs, signal, onSpawn, onProgress } = options;
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(createAbortError('Execution aborted before the process started'));
-            return;
-        }
-        const child = spawn(command, args, {
-            cwd,
-            env,
-            stdio: ['ignore', 'pipe', 'pipe']
-        });
-        let stdout = '';
-        let stderr = '';
-        let timedOut = false;
-        let timeoutId;
-        let killId;
-        let abortDelayId;
-        const cleanup = () => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            if (killId) {
-                clearTimeout(killId);
-            }
-            if (abortDelayId) {
-                clearTimeout(abortDelayId);
-            }
-            if (signal && abortHandler) {
-                signal.removeEventListener('abort', abortHandler);
-            }
-        };
-        const terminate = () => {
-            child.kill('SIGTERM');
-            killId = setTimeout(() => child.kill('SIGKILL'), 5_000);
-            killId.unref?.();
-        };
-        const abortHandler = () => {
-            if (stdout.length === 0 && stderr.length === 0) {
-                abortDelayId = setTimeout(() => {
-                    abortDelayId = undefined;
-                    terminate();
-                }, 15);
-                abortDelayId.unref?.();
-                return;
-            }
-            terminate();
-        };
-        if (signal) {
-            signal.addEventListener('abort', abortHandler, { once: true });
-        }
-        if (timeoutMs !== undefined) {
-            timeoutId = setTimeout(() => {
-                timedOut = true;
-                child.kill('SIGTERM');
-                killId = setTimeout(() => child.kill('SIGKILL'), 5_000);
-                killId.unref?.();
-            }, timeoutMs);
-            timeoutId.unref?.();
-        }
-        child.stdout?.on('data', (chunk) => {
-            const text = chunk.toString();
-            stdout += text;
-            onProgress?.({ stream: 'stdout', text });
-        });
-        child.stderr?.on('data', (chunk) => {
-            const text = chunk.toString();
-            stderr += text;
-            onProgress?.({ stream: 'stderr', text });
-        });
-        onSpawn?.();
-        child.once('error', (error) => {
-            cleanup();
-            reject(error);
-        });
-        child.once('close', (code, exitSignal) => {
-            cleanup();
-            const capture = {
-                stdout,
-                stderr,
-                exitCode: code,
-                exitSignal: exitSignal ?? null
-            };
-            if (signal?.aborted) {
-                const error = createAbortError('Execution cancelled');
-                Object.assign(error, { capture });
-                reject(error);
-                return;
-            }
-            if (timedOut) {
-                reject(new CapturedCommandError(`Command timed out after ${timeoutMs ?? 'unknown'}ms`, capture));
-                return;
-            }
-            resolve(capture);
-        });
-    });
-}
-function createLocalExecutor(stepCaptures, options, buildCommand) {
-    const execute = async (stepName, command, args, cwd, timeoutMs, ignoreExitCode = false) => {
-        const partialCapture = {
-            stdout: '',
-            stderr: '',
-            exitCode: null,
-            exitSignal: null
-        };
-        try {
-            const capture = await runCapturedCommand({
-                command,
-                args,
-                cwd,
-                env: options.env,
-                timeoutMs,
-                signal: options.signal,
-                onSpawn: () => {
-                    stepCaptures.set(stepName, { ...partialCapture });
-                    options.onStepSpawn?.(stepName);
-                },
-                onProgress: (chunk) => {
-                    if (chunk.stream === 'stdout') {
-                        partialCapture.stdout += chunk.text;
-                    }
-                    else {
-                        partialCapture.stderr += chunk.text;
-                    }
-                    stepCaptures.set(stepName, { ...partialCapture });
-                    options.onStepProgress?.(stepName, chunk);
-                    options.onProgress?.(chunk);
-                }
-            });
-            stepCaptures.set(stepName, capture);
-            if (!ignoreExitCode && capture.exitCode !== null && capture.exitCode !== 0) {
-                throw new CapturedCommandError(`Step "${stepName}" exited with code ${capture.exitCode}`, capture);
-            }
-            return capture;
-        }
-        catch (error) {
-            const capture = error instanceof CapturedCommandError ? error.capture : error.capture;
-            if (capture) {
-                stepCaptures.set(stepName, capture);
-            }
-            throw error;
-        }
-    };
-    return {
-        async executeAgentStep(step, agentDef, resolvedTask, timeoutMs) {
-            const extraArgs = agentDef.constraints?.model ? ['--model', agentDef.constraints.model] : undefined;
-            const [command, ...args] = buildCommand(agentDef.cli, extraArgs, resolvedTask);
-            const capture = await execute(step.name, command, args, resolvePath(step.cwd ?? options.cwd), timeoutMs, agentDef.cli === 'opencode');
-            return capture.stdout;
-        },
-        async executeDeterministicStep(step, resolvedCommand, cwd) {
-            const capture = await execute(step.name, 'sh', ['-c', resolvedCommand], resolvePath(cwd), step.timeoutMs);
-            return {
-                output: capture.stdout,
-                exitCode: capture.exitCode ?? 0
-            };
-        }
-    };
-}
 function isObject(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -884,9 +650,16 @@ export const personaCatalog = {
     'cloud-slack-proxy-guard': parsePersonaSpec(cloudSlackProxyGuard, 'cloud-slack-proxy-guard'),
     'sage-cloud-e2e-conduction': parsePersonaSpec(agentRelayE2eConductor, 'sage-cloud-e2e-conduction'),
     'capability-discovery': parsePersonaSpec(capabilityDiscoverer, 'capability-discovery'),
+    'npm-package-compat': parsePersonaSpec(npmPackageBundlerGuard, 'npm-package-compat'),
     posthog: parsePersonaSpec(posthogAgent, 'posthog'),
     'persona-authoring': parsePersonaSpec(personaMaker, 'persona-authoring'),
-    'slop-audit': parsePersonaSpec(antiSlopAuditor, 'slop-audit')
+    'agent-relay-workflow': parsePersonaSpec(agentRelayWorkflow, 'agent-relay-workflow'),
+    'slop-audit': parsePersonaSpec(antiSlopAuditor, 'slop-audit'),
+    'api-contract-review': parsePersonaSpec(apiContractReviewer, 'api-contract-review'),
+    'local-stack-orchestration': parsePersonaSpec(dockerStackWrangler, 'local-stack-orchestration'),
+    'e2e-validation': parsePersonaSpec(e2eValidator, 'e2e-validation'),
+    'write-integration-tests': parsePersonaSpec(integrationTestAuthor, 'write-integration-tests'),
+    'relay-orchestrator': parsePersonaSpec(relayOrchestrator, 'relay-orchestrator')
 };
 export const routingProfiles = {
     default: parseRoutingProfile(defaultRoutingProfileJson, 'routingProfiles.default')
@@ -925,68 +698,19 @@ export function resolvePersonaByTier(intent, tier = 'best-value') {
 }
 /**
  * Resolve a persona for `intent` and return a {@link PersonaContext}
- * bundling the resolved persona, grouped install metadata, and a
- * `sendMessage()` closure for running the persona against a task.
+ * bundling the resolved persona and grouped install metadata.
  *
  * **This is not a React hook.** The `use*` prefix is unfortunate — it is
  * a plain synchronous factory with no implicit state, no side effects,
  * and no rules-of-hooks constraints. Calling `usePersona(intent)` does
  * nothing but resolve routing config and pre-compute the install plan.
- * Nothing is installed, spawned, or written to disk until you call
- * `sendMessage()` (or run the install command yourself).
- *
- * See {@link PersonaContext} for the two usage modes (let `sendMessage()`
- * handle install vs. pre-stage install and pass `installSkills: false`)
- * and the double-install caveat.
+ * Nothing is installed, spawned, or written to disk until you run
+ * `install.commandString` yourself.
  *
  * @example
- * // Mode A — let sendMessage() install skills and run the agent in one call.
- * // Only `status: 'completed'` resolves; non-zero exits / timeouts throw
- * // PersonaExecutionError and cancellation throws AbortError, both with
- * // the typed ExecuteResult attached as `err.result`.
- * const { sendMessage } = usePersona('npm-provenance');
- * try {
- *   const result = await sendMessage('Set up npm trusted publishing for this repo', {
- *     workingDirectory: '.',
- *     timeoutSeconds: 600,
- *   });
- *   // result.status === 'completed' here
- * } catch (err) {
- *   const execErr = err as Error & { result?: ExecuteResult };
- *   console.error('persona run failed', execErr.result?.status, execErr.result?.stderr);
- * }
- *
- * @example
- * // Mode B — pre-stage install out-of-band (e.g. in a Dockerfile), then
- * // run at runtime without re-installing:
- * const { install, sendMessage } = usePersona('npm-provenance');
- * // build/CI step:
+ * const { selection, install } = usePersona('npm-provenance');
  * spawnSync(install.commandString, { shell: true, stdio: 'inherit' });
- * // runtime step:
- * const result = await sendMessage('Your task', {
- *   workingDirectory: '.',
- *   installSkills: false,
- * });
- *
- * @example
- * // Cancellation + streaming progress. Aborting causes `await run` to
- * // throw an AbortError with `err.result.status === 'cancelled'`, so
- * // wrap in try/catch if you plan to abort.
- * const abort = new AbortController();
- * const run = usePersona('npm-provenance').sendMessage('Your task', {
- *   signal: abort.signal,
- *   onProgress: ({ stream, text }) => process[stream].write(text),
- * });
- * run.runId.then((id) => console.log('workflow run id:', id));
- * // ...later:
- * abort.abort(); // or: run.cancel('user requested');
- * try {
- *   const result = await run;
- *   // result.status === 'completed'
- * } catch (err) {
- *   const execErr = err as Error & { result?: ExecuteResult };
- *   // execErr.name === 'AbortError' and execErr.result?.status === 'cancelled'
- * }
+ * // hand `selection` to your harness launcher of choice.
  *
  * @param intent   The persona intent to resolve (e.g. `'npm-provenance'`).
  * @param options  Optional overrides. `harness` forces a specific harness
@@ -1008,7 +732,7 @@ export function usePersona(intent, options = {}) {
  * Same as {@link usePersona}, but takes a pre-resolved {@link PersonaSelection}
  * instead of an intent. Use this when you have a selection produced outside
  * the standard repo catalog — for example, a user-local persona override
- * loaded from disk — and want the same install/sendMessage surface.
+ * loaded from disk.
  */
 export function useSelection(baseSelection, options = {}) {
     const effectiveHarness = options.harness ?? baseSelection.runtime.harness;
@@ -1036,189 +760,9 @@ export function useSelection(baseSelection, options = {}) {
         cleanupCommand,
         cleanupCommandString
     });
-    const sendMessage = (task, sendMessageOptions = {}) => {
-        const runId = createDeferred();
-        // The primary rejection path for any failure in sendMessage() is `resultPromise`
-        // (which the caller awaits via `await execution`). `runId.promise` is an
-        // auxiliary promise that mirrors the same rejection when early setup fails
-        // before the workflow has actually started. Callers are not required to
-        // consume `execution.runId`, so attach a no-op catch here to suppress
-        // the unhandled-rejection warning (and, under Node's default
-        // --unhandled-rejections=throw, an uncaught-exception crash) that would
-        // otherwise fire when both of those conditions hold simultaneously.
-        runId.promise.catch(() => { });
-        const abortController = new AbortController();
-        const unlinkAbort = linkAbortSignal(sendMessageOptions.signal, abortController);
-        const stepName = sanitizeExecutionName(sendMessageOptions.name ?? `${frozenSelection.personaId}-${hash8(task)}`);
-        const workflowName = `use-persona-${stepName}`;
-        const installStepName = `${stepName}-install-skills`;
-        const cleanupStepName = `${stepName}-cleanup-skills`;
-        const workingDirectory = resolvePath(sendMessageOptions.workingDirectory ?? process.cwd());
-        const timeoutMs = Math.max(1, Math.round((sendMessageOptions.timeoutSeconds ??
-            frozenSelection.runtime.harnessSettings.timeoutSeconds) * 1000));
-        const shouldInstallSkills = sendMessageOptions.installSkills !== false && frozenInstallPlan.installs.length > 0;
-        const stepCaptures = new Map();
-        let cancelReason;
-        let workflowRunId;
-        let runIdReadyTimer;
-        const resolveRunId = (value = workflowRunId) => {
-            if (runIdReadyTimer) {
-                clearTimeout(runIdReadyTimer);
-                runIdReadyTimer = undefined;
-            }
-            if (value && !runId.settled) {
-                runId.resolve(value);
-            }
-        };
-        const resultPromise = (async () => {
-            try {
-                const { InMemoryWorkflowDb, WorkflowRunner, buildCommand, workflow } = await import('@agent-relay/sdk/workflows');
-                const executor = createLocalExecutor(stepCaptures, {
-                    cwd: workingDirectory,
-                    env: { ...process.env, ...sendMessageOptions.env },
-                    signal: abortController.signal,
-                    onStepSpawn: (startedStepName) => {
-                        if (startedStepName !== stepName || runId.settled || runIdReadyTimer) {
-                            return;
-                        }
-                        runIdReadyTimer = setTimeout(() => resolveRunId(), 250);
-                        runIdReadyTimer.unref?.();
-                    },
-                    onStepProgress: (progressStepName) => {
-                        if (progressStepName === stepName) {
-                            resolveRunId();
-                        }
-                    },
-                    onProgress: sendMessageOptions.onProgress
-                }, buildCommand);
-                const runner = new WorkflowRunner({
-                    cwd: workingDirectory,
-                    db: new InMemoryWorkflowDb(),
-                    executor
-                });
-                runner.on((event) => {
-                    if (event.type === 'run:started') {
-                        workflowRunId = event.runId;
-                    }
-                    if ((event.type === 'step:completed' || event.type === 'step:failed') &&
-                        event.stepName === stepName) {
-                        resolveRunId(event.runId);
-                    }
-                });
-                const agentName = `${stepName}-agent`;
-                const builder = workflow(workflowName)
-                    .description(`Ad-hoc persona execution for ${frozenSelection.personaId}`)
-                    .pattern('dag')
-                    .timeout(timeoutMs)
-                    .trajectories(false)
-                    .agent(agentName, {
-                    cli: frozenSelection.runtime.harness,
-                    model: frozenSelection.runtime.model,
-                    role: frozenSelection.personaId,
-                    preset: 'worker',
-                    interactive: false,
-                    timeoutMs
-                });
-                if (shouldInstallSkills) {
-                    builder.step(installStepName, {
-                        type: 'deterministic',
-                        command: installCommandString,
-                        cwd: workingDirectory,
-                        timeoutMs,
-                        captureOutput: true,
-                        failOnError: true
-                    });
-                }
-                builder.step(stepName, {
-                    agent: agentName,
-                    task: buildExecutionTask(frozenSelection.runtime.systemPrompt, task, sendMessageOptions.inputs),
-                    cwd: workingDirectory,
-                    timeoutMs,
-                    verification: { type: 'exit_code', value: '0' },
-                    ...(shouldInstallSkills ? { dependsOn: [installStepName] } : {})
-                });
-                // Post-agent cleanup: removes the ephemeral skill artifact paths the
-                // provider scattered during the install step. Only runs when this
-                // sendMessage owns the install (Mode A) AND the agent step completed
-                // — if the agent step fails or is skipped, the dag runner will skip
-                // this step too, which is fine because (a) failure diagnostics stay
-                // on disk for the user to inspect, and (b) `rm -rf` is idempotent so
-                // a follow-up run can re-clean. The lockfile is deliberately not in
-                // cleanupPaths, so repeat runs still benefit from cached resolution.
-                if (shouldInstallSkills && frozenInstall.cleanupCommandString !== ':') {
-                    builder.step(cleanupStepName, {
-                        type: 'deterministic',
-                        command: frozenInstall.cleanupCommandString,
-                        cwd: workingDirectory,
-                        timeoutMs,
-                        captureOutput: true,
-                        failOnError: false,
-                        dependsOn: [stepName]
-                    });
-                }
-                if (abortController.signal.aborted) {
-                    runner.abort();
-                }
-                else {
-                    abortController.signal.addEventListener('abort', () => runner.abort(), { once: true });
-                }
-                const run = (await runner.execute(builder.toConfig()));
-                if (!runId.settled) {
-                    runId.resolve(run.id);
-                }
-                const primaryCapture = stepCaptures.get(stepName);
-                const fallbackCapture = shouldInstallSkills ? stepCaptures.get(installStepName) : undefined;
-                const capture = primaryCapture ?? fallbackCapture;
-                const result = {
-                    status: run.status === 'cancelled'
-                        ? 'cancelled'
-                        : run.status === 'failed' && isTimeoutError(run.error)
-                            ? 'timeout'
-                            : run.status === 'completed'
-                                ? 'completed'
-                                : 'failed',
-                    output: capture?.stdout ?? '',
-                    stderr: capture?.stderr ?? '',
-                    exitCode: capture?.exitCode ?? null,
-                    durationMs: Date.now() - (Date.parse(run.startedAt) || Date.now()),
-                    workflowRunId: run.id,
-                    stepName
-                };
-                if (run.status === 'completed') {
-                    return result;
-                }
-                if (run.status === 'cancelled') {
-                    const error = createAbortError(cancelReason ?? 'Execution cancelled');
-                    Object.assign(error, { result });
-                    throw error;
-                }
-                throw new PersonaExecutionError(run.error ?? `Persona execution failed for step "${stepName}"`, result);
-            }
-            catch (error) {
-                if (!runId.settled) {
-                    runId.reject(error);
-                }
-                throw error;
-            }
-            finally {
-                if (runIdReadyTimer) {
-                    clearTimeout(runIdReadyTimer);
-                }
-                unlinkAbort();
-            }
-        })();
-        return Object.assign(resultPromise, {
-            cancel(reason) {
-                cancelReason = reason;
-                abortController.abort(reason);
-            },
-            runId: runId.promise
-        });
-    };
     return Object.freeze({
         selection: frozenSelection,
-        install: frozenInstall,
-        sendMessage
+        install: frozenInstall
     });
 }
 export * from './eval.js';