@atolis-hq/wake 0.2.27 → 0.2.29

package/dist/src/core/projection-updater.js

@@ -234,6 +234,12 @@ async function applyEvent(current, event, ctx, config) {
             ...(payload.sentinel === 'AWAITING_APPROVAL' && payload.action !== undefined
                 ? { pendingApprovalAction: payload.action }
                 : {}),
+            ...(payload.executionOutcome !== undefined
+                ? { lastExecutionOutcome: payload.executionOutcome }
+                : {}),
+            ...(payload.workflowOutcome !== undefined
+                ? { lastWorkflowOutcome: payload.workflowOutcome }
+                : {}),
         };
         if (payload.sentinel === 'BLOCKED' || payload.sentinel === 'FAILED') {
             nextContext.blockedFromStage = current.wake.stage;

package/dist/src/core/stale-run-reconciler.js

@@ -8,22 +8,111 @@ import { createEventEnvelope } from '../lib/event-log.js';
 // `deliverOutboundEvent` is injected rather than imported so this module does
 // not depend on the outbox module directly.
 export function createStaleRunReconciler(deps) {
+    function isTerminalLifecycle(lifecycle) {
+        return lifecycle === 'TERMINAL';
+    }
+    function recoveryOutcomeForLifecycle(lifecycle) {
+        switch (lifecycle) {
+            case 'CREATED':
+            case 'CLAIMED':
+            case 'PREPARING':
+                return 'CANCELED_BY_RECONCILIATION';
+            case 'PROCESS_STARTING':
+            case 'RUNNING':
+            case 'FINALISING':
+                return 'STALLED';
+            case 'TERMINAL':
+                return 'SUPERSEDED';
+        }
+    }
     async function staleReason(record, now) {
         if (record.status !== 'running') {
             return null;
         }
-        if (deps.isRunningRecordActive !== undefined && !(await deps.isRunningRecordActive(record))) {
+        if (isTerminalLifecycle(record.lifecycle)) {
+            return null;
+        }
+        if (deps.isRunningRecordActive === undefined) {
+            if (record.lifecycle !== 'CREATED' &&
+                record.lifecycle !== 'CLAIMED' &&
+                record.lifecycle !== 'PREPARING') {
+                const startedAtMs = Date.parse(record.startedAt);
+                if (!Number.isFinite(startedAtMs)) {
+                    return 'timeout';
+                }
+                return now.getTime() - startedAtMs >= deps.runnerTimeoutMs() ? 'timeout' : null;
+            }
+            return 'startup-recovery';
+        }
+        const active = await deps.isRunningRecordActive(record);
+        if (active) {
+            const startedAtMs = Date.parse(record.startedAt);
+            if (!Number.isFinite(startedAtMs)) {
+                return 'timeout';
+            }
+            return now.getTime() - startedAtMs >= deps.runnerTimeoutMs() ? 'timeout' : null;
+        }
+        if (record.lifecycle === 'RUNNING' || record.lifecycle === 'PROCESS_STARTING') {
             return 'runner-lock-not-active';
         }
-        const startedAtMs = Date.parse(record.startedAt);
-        if (!Number.isFinite(startedAtMs)) {
-            return 'timeout';
+        return 'startup-recovery';
+    }
+    async function deliverRecoveredLabels(projection, runId, finishedAt) {
+        await deps.deliverOutboundEvent(createLabelsEvent({
+            projection,
+            runId,
+            statusLabel: 'wake:status.failed',
+            stageLabel: stageLabelForStage(projection.wake.stage),
+            workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(projection, deps.config)),
+            occurredAt: finishedAt,
+        }));
+    }
+    async function recoverMissingRunRecordClaims(runRecords, finishedAt) {
+        const knownRunIds = new Set(runRecords.map((record) => record.runId));
+        const projections = await deps.stateStore.listIssueStates();
+        for (const projection of projections) {
+            const runId = projection.wake.lastRunId;
+            if (runId === undefined ||
+                knownRunIds.has(runId) ||
+                runRecords.some((record) => record.workItemKey === projection.workItemKey) ||
+                projection.context.lastRunSentinel !== undefined) {
+                continue;
+            }
+            const event = createEventEnvelope({
+                eventId: `${runId}-missing-run-record-recovered`,
+                workItemKey: projection.workItemKey,
+                streamScope: 'work-item',
+                direction: 'internal',
+                sourceSystem: 'wake',
+                sourceEventType: 'wake.run.completed',
+                sourceRefs: {
+                    repo: projection.issue.repo,
+                    issueNumber: projection.issue.number,
+                    runId,
+                },
+                occurredAt: finishedAt,
+                ingestedAt: finishedAt,
+                trigger: 'immediate',
+                payload: {
+                    action: projection.context.lastRunAction,
+                    sentinel: 'FAILED',
+                    executionOutcome: 'CANCELED_BY_RECONCILIATION',
+                    runId,
+                    reason: 'runner:missing-run-record',
+                },
+            });
+            await deps.stateStore.appendEventEnvelope(event);
+            await deps.projectionUpdater.rebuildFromEvents([event]);
+            const updatedProjection = await deps.stateStore.readIssueState(projection.workItemKey);
+            if (updatedProjection !== null) {
+                await deliverRecoveredLabels(updatedProjection, runId, finishedAt);
+            }
         }
-        return now.getTime() - startedAtMs >= deps.runnerTimeoutMs() ? 'timeout' : null;
     }
     async function reconcileStaleRunningRecords(now) {
         const finishedAt = now.toISOString();
         const runRecords = await deps.stateStore.listRunRecords();
+        await recoverMissingRunRecordClaims(runRecords, finishedAt);
         const staleRecords = [];
         for (const record of runRecords) {
             const reason = await staleReason(record, now);
@@ -46,8 +135,10 @@ export function createStaleRunReconciler(deps) {
             if (projection === null || projection.wake.lastRunId !== record.runId || newerCompletedRun) {
                 await deps.stateStore.writeRunRecord({
                     ...record,
+                    lifecycle: 'TERMINAL',
                     status: 'superseded',
                     finishedAt,
+                    executionOutcome: 'SUPERSEDED',
                     summary: 'Stale running record was superseded by a newer run.',
                     metadata: {
                         ...record.metadata,
@@ -57,15 +148,19 @@ export function createStaleRunReconciler(deps) {
                 });
                 continue;
             }
+            const staleExecutionOutcome = reason === 'timeout' ? 'TIMED_OUT' : recoveryOutcomeForLifecycle(record.lifecycle);
             await deps.stateStore.writeRunRecord({
                 ...record,
+                lifecycle: 'TERMINAL',
                 status: 'failed',
                 finishedAt,
                 sentinel: 'FAILED',
+                executionOutcome: staleExecutionOutcome,
                 summary: `Run exceeded timeout while marked running and was reconciled by a later tick.`,
                 metadata: {
                     ...record.metadata,
                     reconciledBy: 'stale-running-record',
+                    recoveryLifecycle: record.lifecycle,
                     staleReason: reason,
                     timeoutMs: deps.runnerTimeoutMs(),
                 },
@@ -88,8 +183,13 @@ export function createStaleRunReconciler(deps) {
                 payload: {
                     action: record.action,
                     sentinel: 'FAILED',
+                    executionOutcome: staleExecutionOutcome,
                     runId: record.runId,
-                    reason: reason === 'timeout' ? 'runner:stale-timeout' : 'runner:orphaned-process',
+                    reason: reason === 'timeout'
+                        ? 'runner:stale-timeout'
+                        : reason === 'startup-recovery'
+                            ? `runner:recover-${record.lifecycle.toLowerCase()}`
+                            : 'runner:orphaned-process',
                     ...(record.routing === undefined ? {} : { routing: record.routing }),
                 },
             });
@@ -97,14 +197,7 @@ export function createStaleRunReconciler(deps) {
             await deps.projectionUpdater.rebuildFromEvents([runCompletedEvent]);
             const updatedProjection = await deps.stateStore.readIssueState(projection.workItemKey);
             if (updatedProjection !== null) {
-                await deps.deliverOutboundEvent(createLabelsEvent({
-                    projection: updatedProjection,
-                    runId: record.runId,
-                    statusLabel: 'wake:status.failed',
-                    stageLabel: stageLabelForStage(updatedProjection.wake.stage),
-                    workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(updatedProjection, deps.config)),
-                    occurredAt: finishedAt,
-                }));
+                await deliverRecoveredLabels(updatedProjection, record.runId, finishedAt);
             }
         }
     }

package/dist/src/core/tick-runner.js

@@ -446,10 +446,18 @@ export function createTickRunner(deps) {
                 repo: candidate.issue.repo,
                 issueNumber: candidate.issue.number,
                 action,
+                lifecycle: 'CREATED',
                 status: 'running',
                 startedAt: nowIso,
+                routing,
             };
             await deps.stateStore.writeRunRecord(runningRecord);
+            async function transitionRunLifecycle(lifecycle) {
+                await deps.stateStore.writeRunRecord({
+                    ...(await deps.stateStore.readRunRecord(runId)),
+                    lifecycle,
+                });
+            }
             const claimedAt = eventStampNow();
             const claimedEvent = createEventEnvelope({
                 eventId: `${runId}-claimed`,
@@ -473,6 +481,7 @@ export function createTickRunner(deps) {
                 },
             });
             await deps.stateStore.appendEventEnvelope(claimedEvent);
+            await transitionRunLifecycle('CLAIMED');
             await projectionUpdater.rebuildFromEvents([claimedEvent]);
             await deliverOutboundEvent(createLabelsEvent({
                 projection: candidate,
@@ -483,6 +492,7 @@ export function createTickRunner(deps) {
                 occurredAt: eventStampNow(),
             }));
             try {
+                await transitionRunLifecycle('PREPARING');
                 const prepareResult = workspaceMode === 'branch'
                     ? await deps.workspaceManager.prepareWorkspace({
                         workId: candidate.workItemKey,
@@ -499,7 +509,18 @@ export function createTickRunner(deps) {
                 const upstreamChanges = 'upstreamChanges' in prepareResult && typeof prepareResult.upstreamChanges === 'string'
                     ? prepareResult.upstreamChanges
                     : undefined;
+                const preparedRecord = (await deps.stateStore.readRunRecord(runId));
+                await deps.stateStore.writeRunRecord({
+                    ...preparedRecord,
+                    lifecycle: 'PROCESS_STARTING',
+                    metadata: {
+                        ...preparedRecord.metadata,
+                        ...(workspacePath === undefined ? {} : { workspacePath }),
+                        workspaceMode,
+                    },
+                });
                 const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
+                await transitionRunLifecycle('RUNNING');
                 const runnerResult = await deps.runner.run({
                     action,
                     projection: candidate,
@@ -571,8 +592,23 @@ export function createTickRunner(deps) {
                         : { failureClass: runnerResult.failureClass }),
                     ...(runnerResult.routing === undefined ? {} : { routing: runnerResult.routing }),
                 };
+                const executionOutcome = runnerResult.failureClass === 'quota'
+                    ? 'QUOTA_EXHAUSTED'
+                    : runnerResult.failureClass === 'infra'
+                        ? 'PROCESS_FAILED'
+                        : 'COMPLETED';
+                const workflowOutcome = sentinel === 'DONE'
+                    ? 'DONE'
+                    : sentinel === 'BLOCKED'
+                        ? 'BLOCKED'
+                        : sentinel === 'AWAITING_APPROVAL'
+                            ? 'AWAITING_APPROVAL'
+                            : undefined;
+                await transitionRunLifecycle('FINALISING');
+                const finalisingRecord = (await deps.stateStore.readRunRecord(runId));
                 await deps.stateStore.writeRunRecord({
-                    ...runningRecord,
+                    ...finalisingRecord,
+                    lifecycle: 'TERMINAL',
                     status: sentinel === 'DONE'
                         ? 'completed'
                         : sentinel === 'BLOCKED'
@@ -583,10 +619,15 @@ export function createTickRunner(deps) {
                     finishedAt,
                     sessionId: runnerResult.session_id,
                     sentinel,
+                    executionOutcome,
+                    ...(workflowOutcome !== undefined ? { workflowOutcome } : {}),
                     summary: parsedRunnerResult.body,
                     ...(runnerResult.routing === undefined ? {} : { routing: runnerResult.routing }),
                     ...(runnerResult.tokenUsage === undefined ? {} : { tokenUsage: runnerResult.tokenUsage }),
-                    metadata: resultMetadata,
+                    metadata: {
+                        ...finalisingRecord.metadata,
+                        ...resultMetadata,
+                    },
                 });
                 const runCompletedEvent = createEventEnvelope({
                     eventId: `${runId}-completed`,
@@ -626,6 +667,8 @@ export function createTickRunner(deps) {
                             : { handledCommentId: latestHumanCommentId(candidate) }),
                         body: parsedRunnerResult.body,
                         envelope: parsedRunnerResult.envelope,
+                        executionOutcome,
+                        ...(workflowOutcome !== undefined ? { workflowOutcome } : {}),
                     },
                 });
                 await deps.stateStore.appendEventEnvelope(runCompletedEvent);
@@ -668,11 +711,14 @@ export function createTickRunner(deps) {
             catch (err) {
                 const finishedAt = deps.clock.now().toISOString();
                 const sentinel = 'FAILED';
+                const failedRecord = (await deps.stateStore.readRunRecord(runId)) ?? runningRecord;
                 await deps.stateStore.writeRunRecord({
-                    ...runningRecord,
+                    ...failedRecord,
+                    lifecycle: 'TERMINAL',
                     status: 'failed',
                     finishedAt,
                     sentinel,
+                    executionOutcome: 'PROCESS_FAILED',
                     summary: err instanceof Error ? err.message : String(err),
                     metadata: {
                         failureClass: 'infra',
@@ -699,6 +745,7 @@ export function createTickRunner(deps) {
                         runId,
                         reason: 'runner:infrastructure-error',
                         failureClass: 'infra',
+                        executionOutcome: 'PROCESS_FAILED',
                         // Deliberately omit handledCommentId: an infra blip (CLI crash, timeout,
                         // network error) never reached the agent, so it isn't an answer to the
                         // triggering comment. Leaving it unset lets the next tick retry the same

package/dist/src/domain/schema.js

@@ -15,6 +15,37 @@ export const wakeArtifactsEnvelopeSchema = z.object({
     artifacts: z.array(reportedArtifactSchema).default([]),
 });
 export const runnerSentinelSchema = z.enum(runnerSentinelValues);
+export const executionOutcomeValues = [
+    'COMPLETED',
+    'STARTUP_FAILED',
+    'PROCESS_FAILED',
+    'TIMED_OUT',
+    'STALLED',
+    'CANCELED_BY_RECONCILIATION',
+    'CANCELED_BY_OPERATOR',
+    'QUOTA_EXHAUSTED',
+    'MALFORMED_OUTPUT',
+    'SUPERSEDED',
+];
+export const workflowOutcomeValues = [
+    'DONE',
+    'BLOCKED',
+    'AWAITING_APPROVAL',
+    'AWAITING_INPUT',
+    'CHANGES_REQUESTED',
+];
+export const executionAttemptLifecycleValues = [
+    'CREATED',
+    'CLAIMED',
+    'PREPARING',
+    'PROCESS_STARTING',
+    'RUNNING',
+    'FINALISING',
+    'TERMINAL',
+];
+export const executionOutcomeSchema = z.enum(executionOutcomeValues);
+export const workflowOutcomeSchema = z.enum(workflowOutcomeValues);
+export const executionAttemptLifecycleSchema = z.enum(executionAttemptLifecycleValues);
 export const defaultAgentIdentity = 'Wake';
 export const defaultSmokePrompt = `This is ${defaultAgentIdentity}, reply with "hi ${defaultAgentIdentity} only"`;
 const modelOverridesSchema = z
@@ -270,7 +301,20 @@ const runTokenUsageSchema = z.object({
     costUsd: z.number().nonnegative().optional(),
     turns: z.number().nonnegative().optional(),
 });
-export const runRecordSchema = z.object({
+function legacyRunLifecycle(input) {
+    if (input.lifecycle !== undefined) {
+        return input;
+    }
+    return {
+        ...input,
+        lifecycle: input.status === 'running' ? 'RUNNING' : 'TERMINAL',
+    };
+}
+export const runRecordSchema = z.preprocess((input) => {
+    return input !== null && typeof input === 'object'
+        ? legacyRunLifecycle(input)
+        : input;
+}, z.object({
     schemaVersion: z.literal(1),
     runId: z.string(),
     // The work item this run belongs to. Required: run records are Wake-owned
@@ -285,16 +329,26 @@ export const runRecordSchema = z.object({
     repo: z.string(),
     issueNumber: z.number().int().positive(),
     action: identifierSchema,
-    status: z.enum(['running', 'completed', 'awaiting-approval', 'blocked', 'failed', 'superseded']),
+    lifecycle: executionAttemptLifecycleSchema,
+    status: z.enum([
+        'running',
+        'completed',
+        'awaiting-approval',
+        'blocked',
+        'failed',
+        'superseded',
+    ]),
     startedAt: isoTimestampSchema,
     finishedAt: isoTimestampSchema.optional(),
     sessionId: z.string().optional(),
     sentinel: runnerSentinelSchema.optional(),
+    executionOutcome: executionOutcomeSchema.optional(),
+    workflowOutcome: workflowOutcomeSchema.optional(),
     summary: z.string().optional(),
     routing: runnerRoutingSchema.optional(),
     tokenUsage: runTokenUsageSchema.optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
-});
+}));
 const runnerHealthEntrySchema = z.object({
     pausedUntil: isoTimestampSchema.optional(),
     // 'reported' = CLI told us the real reset time; 'estimated' = exponential

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g76dc1bc";
+export const wakeVersion = "gf58d7a3";

package/package.json

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