@atolis-hq/wake 0.3.68 → 0.3.69

package/dist/src/bootstrap/surface-api-execution-applications.js

@@ -10,11 +10,20 @@ export function createExecutionApplications(root, now) {
     return {
         async resolveAmbiguousRun(runId, command) {
             const context = resolutionContext(runId, command.idempotencyKey, now);
-            const run = await root.recovery.resolve(runId, {
-                kind: RunStatus.Failed,
-                failure: { kind: ExecutionFailureCode.Unexpected, message: command.message },
-            }, context);
-            await root.orchestration.resolveExecutionFailure(run.workflowInstanceId, { activationId: run.activationId, runId: run.runId, reason: command.message }, context);
+            const run = await root.recovery.resolve(runId, command.status === RunStatus.Succeeded
+                ? { kind: RunStatus.Succeeded, outcome: command.outcome }
+                : {
+                    kind: RunStatus.Failed,
+                    failure: { kind: ExecutionFailureCode.Unexpected, message: command.reason },
+                }, context);
+            if (command.status === RunStatus.Succeeded)
+                await root.orchestration.acceptOutcome({
+                    workflowInstanceId: run.workflowInstanceId,
+                    activationId: run.activationId,
+                    outcome: run.outcome,
+                }, context);
+            else
+                await root.orchestration.resolveExecutionFailure(run.workflowInstanceId, { activationId: run.activationId, runId: run.runId, reason: command.reason }, context);
             return commandAccepted(command, now());
         },
         async pauseRunner(runnerId, command) {
@@ -97,7 +106,7 @@ export function createExecutionApplications(root, now) {
     };
 }
 function resolutionContext(runId, idempotencyKey, now) {
-    const commandId = `run:${runId}:resolve-failed:${idempotencyKey}`;
+    const commandId = `run:${runId}:resolve:${idempotencyKey}`;
     return {
         commandId,
         correlationId: correlationId(commandId),

package/dist/src/bootstrap/surface-cli-applications.js

@@ -6,7 +6,7 @@ import { createInterface } from 'node:readline/promises';
 import { promisify } from 'node:util';
 import { BuiltInActivityName, agentActivityDefinition } from '../activities/index.js';
 import { IntakeHost, ResidentHost, TickHost } from '../control-plane/index.js';
-import { ExecutionCancellationReason, RunStatus, loadPromptTemplate } from '../execution/index.js';
+import { ExecutionCancellationReason, ExecutionFailureCode, RunStatus, loadPromptTemplate, } from '../execution/index.js';
 import { EventActorKind, correlationId } from '../kernel/index.js';
 import { ResourceCorrelationRole, resourceId } from '../resources/index.js';
 import { DockerProcessError, createApiDispatcher, createApiHttpServer, createLoggedDockerCli, createPackagedAssetSource, createProcessLogSink, createSandboxDockerPort, drainProcessOutput, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, verifyResidentStart, waitForActiveRuns, } from '../surfaces/index.js';
@@ -109,6 +109,26 @@ export function createSurfaceCliApplications(root, api, now) {
                 return root.resources.correlate(resourceId(resource), workItemId(work), ResourceCorrelationRole.Primary, commandContext(`correlate:${resource}:${work}`, now()));
             },
         },
+        runs: {
+            async resolve(runId, resolution) {
+                const context = commandContext(`run:${runId}:resolve`, now());
+                const run = await root.recovery.resolve(runId, resolution.status === RunStatus.Succeeded
+                    ? { kind: RunStatus.Succeeded, outcome: resolution.outcome }
+                    : {
+                        kind: RunStatus.Failed,
+                        failure: { kind: ExecutionFailureCode.Unexpected, message: resolution.reason },
+                    }, context);
+                if (resolution.status === RunStatus.Succeeded)
+                    await root.orchestration.acceptOutcome({
+                        workflowInstanceId: run.workflowInstanceId,
+                        activationId: run.activationId,
+                        outcome: run.outcome,
+                    }, context);
+                else
+                    await root.orchestration.resolveExecutionFailure(run.workflowInstanceId, { activationId: run.activationId, runId: run.runId, reason: resolution.reason }, context);
+                return run;
+            },
+        },
         validateState: createValidationApplications(root),
         sandboxRuntime: createSandboxRuntimeApplications(root),
         operational: createOperationalApplications(root),

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "gdf02688";
+export const wakeVersion = "g2f2caef";

package/dist/src/execution/application/recovery-service.js

@@ -53,11 +53,14 @@ export class RecoveryService {
                 return loaded.view;
             throw new Error(`Run ${id} is not escalated`);
         }
+        const outcome = resolution.kind === RunStatus.Succeeded
+            ? this.activities.validateOutcome(loaded.view.activity, resolution.outcome)
+            : undefined;
         const draft = resolution.kind === RunStatus.Succeeded
             ? createRunExecutionEventDraft({
                 ...resolutionMetadata(currentRunId, loaded.view, context),
                 eventType: ExecutionEventType.RunSucceeded,
-                payload: { outcome: resolution.outcome, finishedAt: context.occurredAt },
+                payload: { outcome: outcome, finishedAt: context.occurredAt },
             })
             : createRunExecutionEventDraft({
                 ...resolutionMetadata(currentRunId, loaded.view, context),

package/dist/src/surfaces/api/routes/commands.js

@@ -1,3 +1,4 @@
+import { RunStatus } from '../../../execution/index.js';
 import { normalizePage } from './pagination.js';
 import { accepted, ApiPathError, decodePathSegment, invalidPath, invalidQuery, invalidRequest, isObject, problem, unavailable, } from './responses.js';
 export async function dispatchCommand(applications, url, body) {
@@ -7,7 +8,7 @@ export async function dispatchCommand(applications, url, body) {
     if (ambiguityResolution !== undefined)
         return ambiguityResolution;
     const request = commandRequest(body);
-    if ('status' in request)
+    if (isHttpResponse(request))
         return request;
     const work = await dispatchWorkCommand(applications, url.pathname, request);
     if (work !== undefined)
@@ -19,14 +20,14 @@ export async function dispatchCommand(applications, url, body) {
     return runner ?? problem(404, 'Not Found', `No command route for ${url.pathname}`);
 }
 async function dispatchAmbiguousRunResolution(applications, pathname, body) {
-    const match = /^\/api\/v1\/runs\/([^/]+)\/commands\/resolve-failed$/.exec(pathname);
+    const match = /^\/api\/v1\/runs\/([^/]+)\/commands\/resolve$/.exec(pathname);
     if (match === null)
         return undefined;
     const runId = decodePathSegment(match[1]);
     if (runId instanceof ApiPathError)
         return invalidPath(runId.message);
-    const request = ambiguityFailureResolutionRequest(body);
-    if ('status' in request)
+    const request = runResolutionRequest(body);
+    if (isHttpResponse(request))
         return request;
     const operation = applications.execution.resolveAmbiguousRun;
     if (operation === undefined)
@@ -98,20 +99,34 @@ function commandRequest(body) {
         ? { idempotencyKey: value }
         : invalidRequest('idempotencyKey', 'Must be at most 200 characters');
 }
-function ambiguityFailureResolutionRequest(body) {
+// eslint-disable-next-line complexity -- each resolution mode validates its exclusive request shape.
+function runResolutionRequest(body) {
     if (!isObject(body))
         return invalidRequest('idempotencyKey', 'A JSON object with an idempotency key is required');
-    if (Object.keys(body).some((key) => key !== 'idempotencyKey' && key !== 'message'))
-        return invalidRequest('', 'The command body contains unknown fields');
     const idempotencyKey = body.idempotencyKey;
     if (typeof idempotencyKey !== 'string' || idempotencyKey.trim() === '')
         return invalidRequest('idempotencyKey', 'Must be a non-empty string');
     if (idempotencyKey.length > 200)
         return invalidRequest('idempotencyKey', 'Must be at most 200 characters');
-    const message = body.message;
-    if (typeof message !== 'string' || message.trim() === '')
-        return invalidRequest('message', 'Must be a non-empty string');
-    if (message.length > 2_000)
-        return invalidRequest('message', 'Must be at most 2000 characters');
-    return { idempotencyKey, message };
+    if (body.status === RunStatus.Succeeded) {
+        if (Object.keys(body).some((key) => key !== 'idempotencyKey' && key !== 'status' && key !== 'outcome'))
+            return invalidRequest('', 'The command body contains unknown fields');
+        if (!Object.hasOwn(body, 'outcome'))
+            return invalidRequest('outcome', 'Is required for success');
+        return { idempotencyKey, status: RunStatus.Succeeded, outcome: body.outcome };
+    }
+    if (body.status === RunStatus.Failed) {
+        if (Object.keys(body).some((key) => key !== 'idempotencyKey' && key !== 'status' && key !== 'reason'))
+            return invalidRequest('', 'The command body contains unknown fields');
+        const reason = body.reason;
+        if (typeof reason !== 'string' || reason.trim() === '')
+            return invalidRequest('reason', 'Must be a non-empty string');
+        if (reason.length > 2_000)
+            return invalidRequest('reason', 'Must be at most 2000 characters');
+        return { idempotencyKey, status: RunStatus.Failed, reason };
+    }
+    return invalidRequest('status', 'Must be either succeeded or failed');
+}
+function isHttpResponse(value) {
+    return typeof value === 'object' && value !== null && 'body' in value;
 }

package/dist/src/surfaces/api/routes/execution.js

@@ -2,7 +2,7 @@ export const executionRoutes = [
     '/api/v1/runs',
     '/api/v1/runs/:runId',
     '/api/v1/runs/:runId/transcript',
-    '/api/v1/runs/:runId/commands/resolve-failed',
+    '/api/v1/runs/:runId/commands/resolve',
     '/api/v1/runners',
     '/api/v1/runners/:runnerId/commands/pause',
     '/api/v1/runners/:runnerId/commands/unpause',

package/dist/src/surfaces/cli/main.js

@@ -1,3 +1,5 @@
+import { readFile } from 'node:fs/promises';
+import { ExecutionStreamKind, RunStatus } from '../../execution/index.js';
 const defaultBudget = { maxAdvances: 100, maxRuns: 100, maxDurationMs: 30_000 };
 /** Parses Surface vocabulary only; Bootstrap supplies every application facade. */
 // eslint-disable-next-line complexity -- command vocabulary is intentionally exhaustive at the Surface boundary.
@@ -12,6 +14,8 @@ export function parseWakeCommand(arguments_) {
                 resource: requiredArgument(first, 'correlate resource'),
                 workItemId: requiredArgument(second, 'correlate work item'),
             };
+        case ExecutionStreamKind.Run:
+            return parseRunCommand(arguments_.slice(1));
         case 'validate-state':
             return parseValidateState(arguments_.slice(1));
         case 'api':
@@ -33,6 +37,64 @@ export function parseWakeCommand(arguments_) {
             throw new Error(`Unknown wake command: ${command ?? ''}`);
     }
 }
+// eslint-disable-next-line complexity -- the resolution flags are mutually exclusive by design.
+function parseRunCommand(arguments_) {
+    if (arguments_[0] !== 'resolve')
+        throw new Error(`Unknown run command: ${arguments_[0] ?? ''}`);
+    const runId = requiredArgument(arguments_[1], 'run id');
+    const values = new Map();
+    for (let index = 2; index < arguments_.length; index += 1) {
+        const flag = arguments_[index];
+        if (flag === '--succeeded' || flag === '--failed') {
+            if (values.has(flag))
+                throw new Error(`Duplicate option: ${flag}`);
+            values.set(flag, '');
+            continue;
+        }
+        if (flag !== '--outcome' && flag !== '--outcome-file' && flag !== '--reason')
+            throw new Error(`Unknown option: ${flag}`);
+        const value = arguments_[index + 1];
+        if (value === undefined || value.startsWith('--'))
+            throw new Error(`Missing value for ${flag}`);
+        if (values.has(flag))
+            throw new Error(`Duplicate option: ${flag}`);
+        values.set(flag, value);
+        index += 1;
+    }
+    const succeeded = values.has('--succeeded');
+    const failed = values.has('--failed');
+    if (succeeded === failed)
+        throw new Error('run resolve requires exactly one of --succeeded or --failed');
+    if (succeeded) {
+        const outcome = values.get('--outcome');
+        const outcomeFile = values.get('--outcome-file');
+        if ((outcome === undefined) === (outcomeFile === undefined))
+            throw new Error('Successful resolution requires exactly one of --outcome or --outcome-file');
+        if (values.has('--reason'))
+            throw new Error('--reason is only valid with --failed');
+        return {
+            kind: 'run-resolve',
+            runId,
+            resolution: outcome === undefined
+                ? { status: RunStatus.Succeeded, outcomeFile: outcomeFile }
+                : { status: RunStatus.Succeeded, outcome: parseJson(outcome) },
+        };
+    }
+    if (values.has('--outcome') || values.has('--outcome-file'))
+        throw new Error('--outcome and --outcome-file are only valid with --succeeded');
+    const reason = values.get('--reason');
+    if (reason === undefined || reason.trim() === '')
+        throw new Error('Failed resolution requires --reason <message>');
+    return { kind: 'run-resolve', runId, resolution: { status: RunStatus.Failed, reason } };
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error('Outcome must be valid JSON');
+    }
+}
 function parseValidateState(arguments_) {
     let rebuildProjections = false;
     let wakeRoot;
@@ -110,6 +172,9 @@ export async function runWakeCommand(command, applications, output, signal) {
         case 'correlate':
             output.write(`${JSON.stringify(await applications.correlate.correlate(command.resource, command.workItemId))}\n`);
             return;
+        case 'run-resolve':
+            output.write(`${JSON.stringify(await runs(applications).resolve(command.runId, await resolveCliOutcome(command.resolution)))}\n`);
+            return;
         case 'validate-state': {
             if (command.rebuildProjections)
                 await applications.validateState.rebuildProjections();
@@ -118,6 +183,21 @@ export async function runWakeCommand(command, applications, output, signal) {
         }
     }
 }
+async function resolveCliOutcome(resolution) {
+    if (resolution.status === RunStatus.Failed)
+        return resolution;
+    return {
+        status: RunStatus.Succeeded,
+        outcome: resolution.outcomeFile === undefined
+            ? resolution.outcome
+            : parseJson(await readFile(resolution.outcomeFile, 'utf8')),
+    };
+}
+function runs(applications) {
+    if (applications.runs === undefined)
+        throw new Error('Run CLI applications were not composed');
+    return applications.runs;
+}
 function writeResult(output, value) {
     if (value !== undefined)
         output.write(`${JSON.stringify(value)}\n`);

package/dist/src/surfaces/cli/usage.js

@@ -12,11 +12,14 @@ export const usage = [
     '  wake ui                    Run the control-plane UI server',
     '  wake audit                 Show autonomous decision audit history',
     '  wake correlate             Manually correlate a resource to a work item',
+    '  wake run resolve           Resolve an escalated ambiguous run',
     '  wake doctor                Diagnose config/GitHub/Docker/sandbox setup problems',
     '  wake --version             Print the installed Wake version',
     '  wake --help                Show this message',
     '',
     'Additional target commands:',
+    '  wake run resolve <run-id> --succeeded (--outcome <json> | --outcome-file <path>)',
+    '  wake run resolve <run-id> --failed --reason <message>',
     '  wake api                   Run the target API surface',
     '  wake sandbox-entrypoint    Run the sandbox resident entrypoint',
     '  wake self-update           Safely update a source installation',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.68",
+  "version": "0.3.69",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {