@atolis-hq/wake 0.3.52 → 0.3.54

package/dist/src/bootstrap/composition-root.js

@@ -155,6 +155,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         lookup,
         orchestration,
         execution,
+        recovery,
         ...(transcriptStore === undefined ? {} : { transcriptStore }),
         runnerControls,
         controlPlane,

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

@@ -1,4 +1,6 @@
 import { ControlStreamKind, ineligibleRunners, } from '../control-plane/index.js';
+import { ExecutionFailureCode, RunStatus } from '../execution/index.js';
+import { correlationId, EventActorKind } from '../kernel/index.js';
 import { ApiCommandStatus, presentRun } from '../surfaces/index.js';
 import { projectionMeta, sampledMeta } from './surface-api-metadata.js';
 import { projectionPage } from './surface-api-projection-pages.js';
@@ -6,6 +8,15 @@ import { withWorkflowContext } from './surface-api-run-context.js';
 import { readWorkTranscript } from './surface-api-transcripts.js';
 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);
+            return commandAccepted(command, now());
+        },
         async pauseRunner(runnerId, command) {
             await root.runnerControls.pause(runnerId, command.idempotencyKey);
             return commandAccepted(command, now());
@@ -85,6 +96,15 @@ export function createExecutionApplications(root, now) {
         },
     };
 }
+function resolutionContext(runId, idempotencyKey, now) {
+    const commandId = `run:${runId}:resolve-failed:${idempotencyKey}`;
+    return {
+        commandId,
+        correlationId: correlationId(commandId),
+        occurredAt: now(),
+        actor: { kind: EventActorKind.Operator, id: 'web' },
+    };
+}
 function commandAccepted(command, acceptedAt) {
     return {
         commandId: `runner:${command.idempotencyKey}`,

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 = "gecabe68";
+export const wakeVersion = "gb23a2a1";

package/dist/src/control-plane/application/advance-once.js

@@ -1,4 +1,4 @@
-import { RunStatus, WorkspaceMode } from '../../execution/index.js';
+import { ActivationClaimConflictError, RunStatus, WorkspaceMode } from '../../execution/index.js';
 import { correlationId, EventActorKind, } from '../../kernel/index.js';
 import { WorkflowStatus } from '../../orchestration/index.js';
 import { WorkStatus } from '../../work/index.js';
@@ -141,15 +141,23 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
         const correlated = await resources.correlationsForWork(selected.workflow.workItemId);
         const resourceViews = (await Promise.all(correlated.map((entry) => resources.get(entry.resourceId)))).filter((resource) => resource !== null);
         const ineligible = await runnerIneligibility();
-        const run = await execution.attempt(selected.activation, {
-            workItemId: selected.workflow.workItemId,
-            workflowInstanceId: selected.workflow.workflowInstanceId,
-            orchestrationGroupId: selected.workflow.orchestrationGroupId,
-            resources: resourceViews,
-            sessionPolicy: selected.workflow.parentWorkflowInstanceId === undefined ? 'resume-stage' : 'fresh',
-            awaitImmediateCompletion: true,
-            ...(ineligible.size === 0 ? {} : { ineligibleRunners: ineligible }),
-        });
+        let run;
+        try {
+            run = await execution.attempt(selected.activation, {
+                workItemId: selected.workflow.workItemId,
+                workflowInstanceId: selected.workflow.workflowInstanceId,
+                orchestrationGroupId: selected.workflow.orchestrationGroupId,
+                resources: resourceViews,
+                sessionPolicy: selected.workflow.parentWorkflowInstanceId === undefined ? 'resume-stage' : 'fresh',
+                awaitImmediateCompletion: true,
+                ...(ineligible.size === 0 ? {} : { ineligibleRunners: ineligible }),
+            });
+        }
+        catch (error) {
+            if (error instanceof ActivationClaimConflictError)
+                return { kind: 'no-work' };
+            throw error;
+        }
         if (run.status === RunStatus.Succeeded && run.outcome !== undefined) {
             if (await isDispatchPaused())
                 return { kind: 'paused' };

package/dist/src/execution/application/activation-claim.js

@@ -2,13 +2,19 @@ import { EventActorKind, EventSourceKind, } from '../../kernel/index.js';
 import { createActivationExecutionEventDraft } from '../contracts/event-factory.js';
 import { decodeActivationExecutionEvent, ExecutionEventType, } from '../contracts/events.js';
 import { activationStream } from '../contracts/streams.js';
+export class ActivationClaimConflictError extends Error {
+    constructor(activationId) {
+        super(`Activation ${activationId} already has an active Run claim`);
+        this.name = 'ActivationClaimConflictError';
+    }
+}
 export async function claimActivation(input) {
     const { journal, clock, config, activationId, runId, owner, occurredAt } = input;
     const stream = activationStream(activationId);
     const events = (await journal.readStream(stream)).map(decodeActivationExecutionEvent);
     const last = events.at(-1);
     if (last?.eventType === ExecutionEventType.ActivationClaimed && claimIsUnexpired(last, clock))
-        throw new Error(`Activation ${activationId} already has an active Run claim`);
+        throw new ActivationClaimConflictError(activationId);
     await journal.append(stream, events.length, [
         createActivationExecutionEventDraft({
             eventId: `${activationId}:claim:${runId}`,

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

@@ -46,8 +46,13 @@ export class RecoveryService {
         const loaded = await this.repository.load(currentRunId);
         if (loaded.view === null)
             throw new Error(`Run ${id} does not exist`);
-        if (!loaded.view.escalated || loaded.view.status !== RunStatus.Ambiguous)
+        if (!loaded.view.escalated || loaded.view.status !== RunStatus.Ambiguous) {
+            if (loaded.events?.some((event) => event.causationId === context.commandId &&
+                (event.eventType === ExecutionEventType.RunSucceeded ||
+                    event.eventType === ExecutionEventType.RunFailed)))
+                return loaded.view;
             throw new Error(`Run ${id} is not escalated`);
+        }
         const draft = resolution.kind === RunStatus.Succeeded
             ? createRunExecutionEventDraft({
                 ...resolutionMetadata(currentRunId, loaded.view, context),

package/dist/src/execution/application/run-repository.js

@@ -9,7 +9,8 @@ export class RunRepository {
     }
     async load(runId) {
         const events = await this.journal.readStream(runStream(runId));
-        return { sequence: events.length, view: foldRun(events.map(decodeRunExecutionEvent)) };
+        const decoded = events.map(decodeRunExecutionEvent);
+        return { sequence: events.length, events: decoded, view: foldRun(decoded) };
     }
     async append(runId, sequence, drafts) {
         const events = await this.journal.append(runStream(runId), sequence, drafts);

package/dist/src/execution/index.js

@@ -1,5 +1,6 @@
 export * from './application/execution-projection.js';
 export * from './application/execution-service.js';
+export * from './application/activation-claim.js';
 export * from './application/recovery-service.js';
 export * from './application/run-repository.js';
 export * from './contracts/commands.js';

package/dist/src/orchestration/application/advance-workflow.js

@@ -80,7 +80,8 @@ export class AdvanceWorkflow {
     async resolveExecutionFailure(id, input, context) {
         const loaded = await this.repository.load(id);
         if (loaded.view === null ||
-            loaded.view.status === WorkflowStatus.Blocked ||
+            (loaded.view.status === WorkflowStatus.Blocked &&
+                !isAmbiguityResolutionBlock(loaded.view.blockReason)) ||
             loaded.view.pendingActivation?.activationId !== input.activationId ||
             loaded.view.acceptedOutcomes.includes(input.activationId))
             return loaded.view;
@@ -203,3 +204,6 @@ export class AdvanceWorkflow {
         return matchWatches(await this.listAllLoaded(), event, this.workflows, context);
     }
 }
+function isAmbiguityResolutionBlock(reason) {
+    return reason !== undefined && /^run-ambiguous-after-\d+-attempts$/.test(reason);
+}

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

@@ -3,6 +3,9 @@ import { accepted, ApiPathError, decodePathSegment, invalidPath, invalidQuery, i
 export async function dispatchCommand(applications, url, body) {
     if (url.search !== '')
         return invalidQuery('Command routes do not accept query parameters');
+    const ambiguityResolution = await dispatchAmbiguousRunResolution(applications, url.pathname, body);
+    if (ambiguityResolution !== undefined)
+        return ambiguityResolution;
     const request = commandRequest(body);
     if ('status' in request)
         return request;
@@ -15,6 +18,21 @@ export async function dispatchCommand(applications, url, body) {
     const runner = await dispatchRunnerCommand(applications, url.pathname, request);
     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);
+    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)
+        return request;
+    const operation = applications.execution.resolveAmbiguousRun;
+    if (operation === undefined)
+        return unavailable('resolve-ambiguous-run', await applications.execution.get?.(runId));
+    return accepted(await operation(runId, request), applications.now());
+}
 async function dispatchWorkCommand(applications, pathname, request) {
     const match = /^\/api\/v1\/work-items\/([^/]+)\/commands\/(freeze|unfreeze|delete|retry)$/.exec(pathname);
     if (match === null)
@@ -80,3 +98,20 @@ function commandRequest(body) {
         ? { idempotencyKey: value }
         : invalidRequest('idempotencyKey', 'Must be at most 200 characters');
 }
+function ambiguityFailureResolutionRequest(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 };
+}

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

@@ -2,6 +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/runners',
     '/api/v1/runners/:runnerId/commands/pause',
     '/api/v1/runners/:runnerId/commands/unpause',

package/package.json

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