@atolis-hq/wake 0.2.51 → 0.2.52

package/dist/src/core/policy-engine.js

@@ -110,7 +110,7 @@ export function createPolicyEngine() {
             const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
             const lastCompletedAction = typeof context.lastCompletedAction === 'string' ? context.lastCompletedAction : undefined;
             const lastRunSentinel = typeof context.lastRunSentinel === 'string' ? context.lastRunSentinel : undefined;
-            const lastFailureClass = typeof context.lastFailureClass === 'string' ? context.lastFailureClass : undefined;
+            const lastRetrySafety = typeof context.lastRetrySafety === 'string' ? context.lastRetrySafety : undefined;
             if (issue.wake.lastRunId === undefined) {
                 return true;
             }
@@ -122,15 +122,15 @@ export function createPolicyEngine() {
             if (isAwaitingApproval(issue)) {
                 return false;
             }
-            if (lastRunSentinel === failedRunnerSentinel && lastFailureClass !== 'quota') {
+            if (lastRunSentinel === failedRunnerSentinel) {
+                if (lastRetrySafety === 'SAFE_TO_RETRY' || lastRetrySafety === 'SAFE_TO_RESUME') {
+                    return belowFailureRetryLimit(issue, config);
+                }
                 return false;
             }
             if (lastRunSentinel === 'BLOCKED') {
                 return false;
             }
-            if (lastFailureClass === 'quota') {
-                return belowFailureRetryLimit(issue, config);
-            }
             const workflowAction = chooseWorkflowAction(issue, workflow);
             return workflowAction !== null && lastCompletedAction !== workflowAction.action;
         },

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

@@ -253,6 +253,17 @@ async function applyEvent(current, event, ctx, config) {
             ...(payload.workflowOutcome !== undefined
                 ? { lastWorkflowOutcome: payload.workflowOutcome }
                 : {}),
+            ...(payload.failurePhase !== undefined ? { lastFailurePhase: payload.failurePhase } : {}),
+            ...(payload.processStarted !== undefined
+                ? { lastProcessStarted: payload.processStarted }
+                : {}),
+            ...(payload.workspaceChanged !== undefined
+                ? { lastWorkspaceChanged: payload.workspaceChanged }
+                : {}),
+            ...(payload.externalSideEffects !== undefined
+                ? { lastExternalSideEffects: payload.externalSideEffects }
+                : {}),
+            ...(payload.retrySafety !== undefined ? { lastRetrySafety: payload.retrySafety } : {}),
         };
         if (payload.sentinel === 'BLOCKED' || payload.sentinel === 'FAILED') {
             nextContext.blockedFromStage = current.wake.stage;

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

@@ -26,6 +26,37 @@ export function createStaleRunReconciler(deps) {
                 return 'SUPERSEDED';
         }
     }
+    function failurePhaseForLifecycle(lifecycle) {
+        switch (lifecycle) {
+            case 'CREATED':
+            case 'CLAIMED':
+            case 'PREPARING':
+                return 'workspace-prep';
+            case 'PROCESS_STARTING':
+                return 'process-starting';
+            case 'RUNNING':
+            case 'FINALISING':
+                return 'running';
+            case 'TERMINAL':
+                return 'unknown';
+        }
+    }
+    function classifyReconciledFailure(record) {
+        const processStarted = record.agentPid !== undefined ||
+            record.agentProcessStartedAt !== undefined ||
+            record.lifecycle === 'RUNNING' ||
+            record.lifecycle === 'FINALISING';
+        const metadata = record.metadata;
+        const workspaceChanged = typeof metadata?.workspacePath === 'string';
+        const retrySafety = processStarted || workspaceChanged ? 'REQUIRES_RECONCILIATION' : 'SAFE_TO_RETRY';
+        return {
+            failurePhase: failurePhaseForLifecycle(record.lifecycle),
+            processStarted,
+            workspaceChanged,
+            externalSideEffects: processStarted ? 'unknown' : 'none',
+            retrySafety,
+        };
+    }
     async function staleReason(record, now) {
         if (record.status !== 'running') {
             return null;
@@ -94,6 +125,11 @@ export function createStaleRunReconciler(deps) {
                     action: projection.context.lastRunAction,
                     sentinel: 'FAILED',
                     executionOutcome: 'CANCELED_BY_RECONCILIATION',
+                    failurePhase: 'unknown',
+                    processStarted: false,
+                    workspaceChanged: false,
+                    externalSideEffects: 'unknown',
+                    retrySafety: 'MANUAL_REVIEW_REQUIRED',
                     runId,
                     reason: 'runner:missing-run-record',
                 },
@@ -146,6 +182,7 @@ export function createStaleRunReconciler(deps) {
                 continue;
             }
             const staleExecutionOutcome = reason === 'timeout' ? 'TIMED_OUT' : recoveryOutcomeForLifecycle(record.lifecycle);
+            const failureContext = classifyReconciledFailure(record);
             await deps.stateStore.writeRunRecord({
                 ...record,
                 lifecycle: 'TERMINAL',
@@ -153,6 +190,7 @@ export function createStaleRunReconciler(deps) {
                 finishedAt,
                 sentinel: 'FAILED',
                 executionOutcome: staleExecutionOutcome,
+                ...failureContext,
                 summary: `Run exceeded timeout while marked running and was reconciled by a later tick.`,
                 metadata: {
                     ...record.metadata,
@@ -160,6 +198,7 @@ export function createStaleRunReconciler(deps) {
                     recoveryLifecycle: record.lifecycle,
                     staleReason: reason,
                     timeoutMs: deps.runnerTimeoutMs(),
+                    ...failureContext,
                 },
             });
             const runCompletedEvent = createEventEnvelope({
@@ -181,6 +220,7 @@ export function createStaleRunReconciler(deps) {
                     action: record.action,
                     sentinel: 'FAILED',
                     executionOutcome: staleExecutionOutcome,
+                    ...failureContext,
                     runId: record.runId,
                     reason: reason === 'timeout'
                         ? 'runner:stale-timeout'

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

@@ -52,6 +52,54 @@ function shouldPublishRunResult(input) {
     }
     return input.failureClass !== input.previousFailureClass;
 }
+function hasConfirmedExternalSideEffect(projection) {
+    return projection.correlatedResources.some((resource) => /^[a-z0-9-]+:pr:/.test(resource.resourceUri));
+}
+function failurePhaseForRecord(record) {
+    if (record.agentPid !== undefined || record.agentProcessStartedAt !== undefined) {
+        return 'running';
+    }
+    if (record.lifecycle === 'PROCESS_STARTING' || record.lifecycle === 'RUNNING') {
+        return 'process-starting';
+    }
+    if (record.lifecycle === 'PREPARING') {
+        return 'workspace-prep';
+    }
+    return 'unknown';
+}
+function classifyFailedRun(input) {
+    const processStarted = input.record.agentPid !== undefined || input.record.agentProcessStartedAt !== undefined;
+    const workspaceChanged = input.workspacePath !== undefined;
+    const externalSideEffects = hasConfirmedExternalSideEffect(input.projection)
+        ? 'confirmed'
+        : processStarted
+            ? 'unknown'
+            : 'none';
+    const failurePhase = input.failurePhase ??
+        (input.envelope === 'degraded' && input.sentinel === 'FAILED'
+            ? 'result-parsing'
+            : failurePhaseForRecord(input.record));
+    let retrySafety;
+    if (input.failureClass === 'task') {
+        retrySafety = 'NOT_RETRYABLE';
+    }
+    else if (externalSideEffects === 'confirmed' || workspaceChanged) {
+        retrySafety = 'REQUIRES_RECONCILIATION';
+    }
+    else if (processStarted) {
+        retrySafety = 'SAFE_TO_RESUME';
+    }
+    else {
+        retrySafety = 'SAFE_TO_RETRY';
+    }
+    return {
+        failurePhase,
+        processStarted,
+        workspaceChanged,
+        externalSideEffects,
+        retrySafety,
+    };
+}
 export function createTickRunner(deps) {
     const policy = createPolicyEngine();
     const lifecycle = createLifecycleService();
@@ -1464,6 +1512,16 @@ export function createTickRunner(deps) {
                             : undefined;
                 await transitionRunLifecycle('FINALISING');
                 const finalisingRecord = (await deps.stateStore.readRunRecord(runId));
+                const failureContext = sentinel === 'FAILED'
+                    ? classifyFailedRun({
+                        projection: candidate,
+                        record: finalisingRecord,
+                        failureClass: runnerResult.failureClass ?? 'task',
+                        ...(workspacePath === undefined ? {} : { workspacePath }),
+                        envelope: parsedRunnerResult.envelope,
+                        sentinel,
+                    })
+                    : undefined;
                 await deps.stateStore.writeRunRecord({
                     ...finalisingRecord,
                     lifecycle: 'TERMINAL',
@@ -1479,6 +1537,7 @@ export function createTickRunner(deps) {
                     sentinel,
                     executionOutcome,
                     ...(workflowOutcome !== undefined ? { workflowOutcome } : {}),
+                    ...(failureContext === undefined ? {} : failureContext),
                     summary: parsedRunnerResult.body,
                     ...(runnerResult.routing === undefined ? {} : { routing: runnerResult.routing }),
                     ...(runnerResult.tokenUsage === undefined ? {} : { tokenUsage: runnerResult.tokenUsage }),
@@ -1519,6 +1578,7 @@ export function createTickRunner(deps) {
                         ...(runnerResult.failureClass === undefined
                             ? {}
                             : { failureClass: runnerResult.failureClass }),
+                        ...(failureContext === undefined ? {} : failureContext),
                         // Only mark the triggering comment handled when the run reached the
                         // agent and produced a real outcome. Quota/infra failures are transient
                         // blips, not an answer to the human's comment — leaving handledCommentId
@@ -1612,6 +1672,18 @@ export function createTickRunner(deps) {
                 const finishedAt = deps.clock.now().toISOString();
                 const sentinel = 'FAILED';
                 const failedRecord = (await deps.stateStore.readRunRecord(runId)) ?? runningRecord;
+                const failedRecordMetadata = failedRecord.metadata;
+                const failedRecordWorkspacePath = typeof failedRecordMetadata?.workspacePath === 'string'
+                    ? failedRecordMetadata.workspacePath
+                    : undefined;
+                const failureContext = classifyFailedRun({
+                    projection: candidate,
+                    record: failedRecord,
+                    failureClass: 'infra',
+                    ...(failedRecordWorkspacePath === undefined
+                        ? {}
+                        : { workspacePath: failedRecordWorkspacePath }),
+                });
                 await deps.stateStore.writeRunRecord({
                     ...failedRecord,
                     lifecycle: 'TERMINAL',
@@ -1619,10 +1691,12 @@ export function createTickRunner(deps) {
                     finishedAt,
                     sentinel,
                     executionOutcome: 'PROCESS_FAILED',
+                    ...failureContext,
                     summary: err instanceof Error ? err.message : String(err),
                     metadata: {
                         ...failedRecord.metadata,
                         failureClass: 'infra',
+                        ...failureContext,
                     },
                 });
                 const runCompletedEvent = createEventEnvelope({
@@ -1646,6 +1720,7 @@ export function createTickRunner(deps) {
                         runId,
                         reason: 'runner:infrastructure-error',
                         failureClass: 'infra',
+                        ...failureContext,
                         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

package/dist/src/domain/schema.js

@@ -326,6 +326,22 @@ const runLeaseSchema = z.object({
     lastRenewedAt: isoTimestampSchema,
     expiresAt: isoTimestampSchema,
 });
+export const failurePhaseSchema = z.enum([
+    'workspace-prep',
+    'process-starting',
+    'running',
+    'result-parsing',
+    'publishing',
+    'unknown',
+]);
+export const externalSideEffectsSchema = z.enum(['none', 'confirmed', 'unknown']);
+export const retrySafetySchema = z.enum([
+    'SAFE_TO_RETRY',
+    'SAFE_TO_RESUME',
+    'REQUIRES_RECONCILIATION',
+    'MANUAL_REVIEW_REQUIRED',
+    'NOT_RETRYABLE',
+]);
 function legacyRunLifecycle(input) {
     if (input.lifecycle !== undefined) {
         return input;
@@ -369,6 +385,11 @@ export const runRecordSchema = z.preprocess((input) => {
     sentinel: runnerSentinelSchema.optional(),
     executionOutcome: executionOutcomeSchema.optional(),
     workflowOutcome: workflowOutcomeSchema.optional(),
+    failurePhase: failurePhaseSchema.optional(),
+    processStarted: z.boolean().optional(),
+    workspaceChanged: z.boolean().optional(),
+    externalSideEffects: externalSideEffectsSchema.optional(),
+    retrySafety: retrySafetySchema.optional(),
     summary: z.string().optional(),
     routing: runnerRoutingSchema.optional(),
     lease: runLeaseSchema.optional(),

package/dist/src/version.js

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

package/package.json

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