@atolis-hq/wake 0.3.82 → 0.3.84

package/dist/src/activities/agent/agent-activity.js

@@ -175,7 +175,13 @@ function agentOutcome(result) {
         return {
             kind: ActivityOutcomeKind.Failed,
             data: {
-                reason: ActivityFailureCode.RunnerFailed,
+                // 'provider-quota-exceeded' is a literal, not execution's ProviderQuotaExceededFailureKind
+                // import: activities sits below execution in the module dependency order and must not
+                // import it. AgentRunnerPort's failure.kind is an open string per the existing runner
+                // contract convention; this is the one place that interprets it.
+                reason: result.failure?.kind === 'provider-quota-exceeded'
+                    ? ActivityFailureCode.RunnerQuotaExceeded
+                    : ActivityFailureCode.RunnerFailed,
                 ...(result.failure === undefined ? {} : { message: result.failure.message }),
             },
         };

package/dist/src/activities/agent/agent-result.js

@@ -14,7 +14,11 @@ const blockedReason = z
     .strict();
 const failedReason = z
     .object({
-    reason: z.enum([ActivityFailureCode.InvalidAgentResult, ActivityFailureCode.RunnerFailed]),
+    reason: z.enum([
+        ActivityFailureCode.InvalidAgentResult,
+        ActivityFailureCode.RunnerFailed,
+        ActivityFailureCode.RunnerQuotaExceeded,
+    ]),
     message: z.string().optional(),
 })
     .strict();

package/dist/src/activities/contracts/vocabulary.js

@@ -31,6 +31,7 @@ export const ActivityFailureCode = defineClosedVocabulary({
     InvalidAgentResult: 'invalid-agent-result',
     AmbiguousRunnerResult: 'ambiguous-runner-result',
     RunnerFailed: 'runner-failed',
+    RunnerQuotaExceeded: 'runner-quota-exceeded',
 });
 export const ActivityOutcomeKind = defineClosedVocabulary({
     Waiting: 'waiting',

package/dist/src/bootstrap/index.js

@@ -4,8 +4,8 @@ import { createRuntimeProjectionRunner } from './projection-runtime.js';
 export function composeDeliveryService(dependencies) {
     return new DeliveryService(dependencies);
 }
-export function composeDeliveryOutcomeReactor(journal, checkpoints, orchestration) {
-    return new DeliveryOutcomeReactor(journal, checkpoints, orchestration);
+export function composeDeliveryOutcomeReactor(journal, checkpoints, orchestration, projections) {
+    return new DeliveryOutcomeReactor(journal, checkpoints, orchestration, projections);
 }
 export function composeDeliveryRuntime(dependencies) {
     const projectionRunner = createRuntimeProjectionRunner(dependencies.journal, dependencies.projections, dependencies.checkpoints);
@@ -16,7 +16,7 @@ export function composeDeliveryRuntime(dependencies) {
         adapter: dependencies.adapter,
         now: dependencies.now,
     });
-    const reactor = composeDeliveryOutcomeReactor(dependencies.journal, dependencies.checkpoints, dependencies.orchestration);
+    const reactor = composeDeliveryOutcomeReactor(dependencies.journal, dependencies.checkpoints, dependencies.orchestration, dependencies.projections);
     return {
         async runOnce(signal) {
             await projectionRunner.runRegisteredOnce();

package/dist/src/bootstrap/integration-runtime.js

@@ -120,7 +120,7 @@ export async function composeIntegrationRuntime(input) {
         await resourceTransitions.drain();
         return operation();
     });
-    const outcomes = new DeliveryOutcomeReactor(input.journal, input.checkpoints, input.orchestration);
+    const outcomes = new DeliveryOutcomeReactor(input.journal, input.checkpoints, input.orchestration, input.projections);
     const catchUpProjections = async () => {
         await projectionRunner.runRegisteredOnce();
     };

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

@@ -13,6 +13,7 @@ function serializeJournalAppends(journal) {
         readStream: (stream) => journal.readStream(stream),
         readAll: (afterGlobalPosition, limit) => journal.readAll(afterGlobalPosition, limit),
         latestGlobalPosition: () => journal.latestGlobalPosition(),
+        changeSignal: journal.changeSignal,
         ...(journal.readLatest === undefined
             ? {}
             : {

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

@@ -39,12 +39,13 @@ export function createSurfaceCliApplications(root, api, now) {
     // hammered every cycle instead of given a chance to recover.
     const runnerResident = new ResidentHost(runnerTick, (signal, { consecutiveIdleTicks, consecutiveErrorTicks }) => {
         if (consecutiveErrorTicks > 0)
-            return sleepUntilAbort(signal, nextIdleBackoffMs(root.config.controlPlane.resident, consecutiveErrorTicks));
+            return sleepUntilAbort(signal, nextPollBackoffMs(root.config.controlPlane.resident, consecutiveErrorTicks));
+        // Genuine idle (no errors): wait for the journal to actually change.
         return consecutiveIdleTicks === 0
             ? Promise.resolve()
-            : sleepUntilAbort(signal, root.config.controlPlane.resident?.idleBackoffMs ?? 1000);
+            : root.journal.changeSignal.waitForChange(signal, JOURNAL_WAIT_FALLBACK_MS);
     }, reportResidentError('runner'));
-    const intakeResident = new ResidentHost(intakeHost, (signal, { consecutiveIdleTicks }) => sleepUntilAbort(signal, nextIdleBackoffMs(root.config.controlPlane.resident, consecutiveIdleTicks)), reportResidentError('intake'));
+    const intakeResident = new ResidentHost(intakeHost, (signal, { consecutiveIdleTicks }) => sleepUntilAbort(signal, nextPollBackoffMs(root.config.controlPlane.resident, consecutiveIdleTicks)), reportResidentError('intake'));
     const servers = new Set();
     const startHttp = createHttpStarter(root, api, servers);
     return {
@@ -134,8 +135,11 @@ export function createSurfaceCliApplications(root, api, now) {
         operational: createOperationalApplications(root),
     };
 }
+// Safety net for a missed in-process notify() or a cross-process writer the
+// EventEmitter can't see; a real append wakes waiters within milliseconds
+// regardless, so there's no operational reason to make this configurable.
+const JOURNAL_WAIT_FALLBACK_MS = 30_000;
 export async function runProjectionPump(root, signal) {
-    const intervalMs = 1000;
     while (!signal.aborted) {
         try {
             await root.projectionRunner.runRegisteredOnce();
@@ -143,12 +147,12 @@ export async function runProjectionPump(root, signal) {
         catch (error) {
             process.stderr.write(`Wake projection pump failed: ${error instanceof Error ? error.message : String(error)}\n`);
         }
-        await sleepUntilAbort(signal, intervalMs);
+        await root.journal.changeSignal.waitForChange(signal, JOURNAL_WAIT_FALLBACK_MS);
     }
 }
-function nextIdleBackoffMs(resident, consecutiveIdleTicks) {
-    const baseMs = resident?.idleBackoffMs ?? 1000;
-    const maxMs = resident?.maxIdleBackoffMs ?? baseMs * 16;
+function nextPollBackoffMs(resident, consecutiveIdleTicks) {
+    const baseMs = resident?.pollBackoffMs ?? 1000;
+    const maxMs = resident?.maxPollBackoffMs ?? baseMs * 16;
     return Math.min(baseMs * 2 ** Math.min(consecutiveIdleTicks, 20), maxMs);
 }
 function sleepUntilAbort(signal, milliseconds) {

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 = "ga32fb11";
+export const wakeVersion = "g80c78a2";

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

@@ -1,6 +1,30 @@
-import { ActivationClaimConflictError, RunStatus, WorkspaceMode } from '../../execution/index.js';
+/* eslint-disable complexity, max-lines-per-function */
+import { ActivityFailureCode, ActivityOutcomeKind, } from '../../activities/index.js';
+import { ActivationClaimConflictError, NoEligibleRunnerError, RunStatus, WorkspaceMode, } from '../../execution/index.js';
 import { WorkflowStatus } from '../../orchestration/index.js';
 import { isExecutionFailureTerminal } from './execution-reconciliation.js';
+export function isRunnerQuotaOutcome(outcome) {
+    return (outcome.kind === ActivityOutcomeKind.Failed &&
+        typeof outcome.data === 'object' &&
+        outcome.data !== null &&
+        'reason' in outcome.data &&
+        outcome.data.reason === ActivityFailureCode.RunnerQuotaExceeded);
+}
+export function runnerQuotaMessage(outcome) {
+    const data = outcome.data;
+    return typeof data.message === 'string' ? data.message : 'runner reported quota exhaustion';
+}
+/**
+ * A quota retry deliberately leaves the outcome unaccepted, so a port that
+ * never applied it (absent method, or a workflow instance that vanished)
+ * leaves the Run permanently unresolved. Surface that rather than going
+ * silent; it is an operational defect, not a workflow state.
+ */
+export function reportUnappliedRunnerQuotaRetry(result, input) {
+    if (result !== null && result !== undefined)
+        return;
+    console.error(`Runner-quota retry was not applied for activation ${input.activationId} (run ${input.runId}); its outcome remains unaccepted.`);
+}
 /**
  * Fills open capacity within one Advancement call: dispatches ready
  * activations one at a time, rechecking `maxConcurrentRuns` and reselecting
@@ -73,18 +97,40 @@ export async function runDispatchLoop(pending, ctx) {
                 stopReason = { kind: 'no-work' };
                 break;
             }
+            if (error instanceof NoEligibleRunnerError) {
+                stopReason = { kind: 'no-work' };
+                break;
+            }
             throw error;
         }
         if (run.status === RunStatus.Succeeded && run.outcome !== undefined) {
-            if (await ctx.isDispatchPaused()) {
-                stopReason = { kind: 'paused' };
-                break;
+            if (isRunnerQuotaOutcome(run.outcome)) {
+                // No isDispatchPaused check here: a quota retry re-requests the same
+                // stage's activity without publishing an outcome or consuming retry
+                // budget, so it must not be held behind maintenance pause the way an
+                // outward-publishing acceptOutcome call is below.
+                const retried = await ctx.orchestration.retryRunnerQuotaFailure?.(selected.workflow.workflowInstanceId, {
+                    activationId: selected.activation.activationId,
+                    runId: run.runId,
+                    runnerName: run.runner?.name ?? 'unknown-runner',
+                    message: runnerQuotaMessage(run.outcome),
+                }, ctx.commandContext(run.runId));
+                reportUnappliedRunnerQuotaRetry(retried, {
+                    activationId: selected.activation.activationId,
+                    runId: run.runId,
+                });
+            }
+            else {
+                if (await ctx.isDispatchPaused()) {
+                    stopReason = { kind: 'paused' };
+                    break;
+                }
+                await ctx.orchestration.acceptOutcome({
+                    workflowInstanceId: selected.workflow.workflowInstanceId,
+                    activationId: selected.activation.activationId,
+                    outcome: run.outcome,
+                }, ctx.commandContext(run.runId));
             }
-            await ctx.orchestration.acceptOutcome({
-                workflowInstanceId: selected.workflow.workflowInstanceId,
-                activationId: selected.activation.activationId,
-                outcome: run.outcome,
-            }, ctx.commandContext(run.runId));
         }
         if (isExecutionFailureTerminal(run.status))
             await ctx.orchestration.resolveExecutionFailure?.(selected.workflow.workflowInstanceId, {

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

@@ -5,7 +5,7 @@ import { isAmbiguityResolutionBlock, WorkflowStatus } from '../../orchestration/
 import { WorkStatus } from '../../work/index.js';
 import { ControlStreamKind } from '../contracts/streams.js';
 import { DispatchPolicy } from '../domain/dispatch-policy.js';
-import { runDispatchLoop } from './advance-once-dispatch.js';
+import { isRunnerQuotaOutcome, reportUnappliedRunnerQuotaRetry, runDispatchLoop, runnerQuotaMessage, } from './advance-once-dispatch.js';
 import { findUnresolvedSucceededTerminal, findUnresolvedTerminal, } from './execution-reconciliation.js';
 export function createAdvanceOnce(orchestration, execution, resources, clock, dependencies) {
     const runnerIneligibility = dependencies.runnerIneligibility ?? (async () => new Set());
@@ -96,11 +96,29 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
             if (await isDispatchPaused())
                 return { kind: 'paused' };
             if (recovery.run.status === RunStatus.Succeeded) {
-                await orchestration.acceptOutcome({
-                    workflowInstanceId: recovery.item.workflow.workflowInstanceId,
-                    activationId: recovery.item.activation.activationId,
-                    outcome: recovery.run.outcome,
-                }, context(recovery.run.runId));
+                // An agent Run completes after execution.attempt() has already returned,
+                // so this reconciliation — not the dispatch loop — is where a real
+                // quota-classified outcome is resolved. It must divert here too, or the
+                // quota failure is published and charged to the retry budget after all.
+                if (isRunnerQuotaOutcome(recovery.run.outcome)) {
+                    const retried = await orchestration.retryRunnerQuotaFailure?.(recovery.item.workflow.workflowInstanceId, {
+                        activationId: recovery.item.activation.activationId,
+                        runId: recovery.run.runId,
+                        runnerName: recovery.run.runner?.name ?? 'unknown-runner',
+                        message: runnerQuotaMessage(recovery.run.outcome),
+                    }, context(recovery.run.runId));
+                    reportUnappliedRunnerQuotaRetry(retried, {
+                        activationId: recovery.item.activation.activationId,
+                        runId: recovery.run.runId,
+                    });
+                }
+                else {
+                    await orchestration.acceptOutcome({
+                        workflowInstanceId: recovery.item.workflow.workflowInstanceId,
+                        activationId: recovery.item.activation.activationId,
+                        outcome: recovery.run.outcome,
+                    }, context(recovery.run.runId));
+                }
                 return {
                     kind: 'progressed',
                     dispatched: [

package/dist/src/control-plane/application/control-plane-service.js

@@ -2,22 +2,36 @@ import { EventActorKind, correlationId, } from '../../kernel/index.js';
 import { ControlEventType, createControlEventDraft, selectControlEvent, } from '../contracts/events.js';
 import { controlPlaneStream } from '../contracts/streams.js';
 export function createControlPlaneService(input) {
+    // isPaused() is checked many times per pipeline run, so memoize by
+    // journal position to skip the read entirely when nothing has moved.
+    let cached;
     return {
         pause: (key) => change(input, key, 'pause'),
         resume: (key) => change(input, key, 'resume'),
         async isPaused() {
-            let paused = false;
-            for (const envelope of await input.journal.readStream(controlPlaneStream())) {
-                const event = selectControlEvent(envelope);
-                if (event?.eventType === ControlEventType.DispatchPaused)
-                    paused = true;
-                if (event?.eventType === ControlEventType.DispatchResumed)
-                    paused = false;
-            }
+            const position = await input.journal.latestGlobalPosition();
+            if (cached !== undefined && cached.position === position)
+                return cached.paused;
+            const paused = await currentIsPaused(input.journal);
+            cached = { position, paused };
             return paused;
         },
     };
 }
+async function currentIsPaused(journal) {
+    return isPausedIn(await journal.readStream(controlPlaneStream()));
+}
+function isPausedIn(events) {
+    let paused = false;
+    for (const envelope of events) {
+        const event = selectControlEvent(envelope);
+        if (event?.eventType === ControlEventType.DispatchPaused)
+            paused = true;
+        if (event?.eventType === ControlEventType.DispatchResumed)
+            paused = false;
+    }
+    return paused;
+}
 async function change(input, idempotencyKey, operation) {
     const stream = controlPlaneStream();
     const events = await input.journal.readStream(stream);
@@ -25,7 +39,7 @@ async function change(input, idempotencyKey, operation) {
     const correlation = correlationId(`control:${operation}:${idempotencyKey}`);
     if (events.some((event) => event.eventType === eventType && event.correlationId === correlation))
         return;
-    const currentlyPaused = await createControlPlaneService(input).isPaused();
+    const currentlyPaused = isPausedIn(events);
     if ((operation === 'pause' && currentlyPaused) || (operation === 'resume' && !currentlyPaused))
         return;
     const occurredAt = input.clock.now().toISOString();

package/dist/src/control-plane/contracts/config.js

@@ -14,10 +14,13 @@ export const controlPlaneConfigSchema = z
     schedules: z.array(scheduleSchema).default([]),
     resident: z
         .object({
-        idleBackoffMs: z.number().int().positive().default(1000),
-        maxIdleBackoffMs: z.number().int().positive().optional(),
+        // Backoff for the resident loop's own retry cadence when idle or
+        // erroring, not a per-adapter rate limit (e.g.
+        // integrations.github.polling.intervalMs gates the actual call).
+        pollBackoffMs: z.number().int().positive().default(1000),
+        maxPollBackoffMs: z.number().int().positive().optional(),
     })
         .strict()
-        .default({ idleBackoffMs: 1000 }),
+        .default({ pollBackoffMs: 1000 }),
 })
     .strict();

package/dist/src/execution/application/execution-activity.js

@@ -1,4 +1,5 @@
 import { ExecutionEventType } from '../contracts/events.js';
+import { ProviderQuotaExceededFailureKind } from '../contracts/runner.js';
 import { parseAgentRunnerResponse } from '../infrastructure/agent-runner-adapter.js';
 import { createRunEvent } from './run-lifecycle.js';
 export async function executeActivity(runtime, currentRunId, request) {
@@ -77,7 +78,8 @@ function runnerResultReporter(runtime, currentRunId, context, activation, reques
             payload: { transport: result.transport, agent: parseAgentRunnerResponse(result) },
         });
         await appendIdempotently(runtime.repository, currentRunId, loaded.sequence, event);
-        if (result.failure?.kind === 'provider-quota-exceeded' && request.runnerName !== undefined)
+        if (result.failure?.kind === ProviderQuotaExceededFailureKind &&
+            request.runnerName !== undefined)
             await runtime.dependencies.reportRunnerQuota?.({
                 runnerName: request.runnerName,
                 message: result.failure.message,

package/dist/src/execution/contracts/runner.js

@@ -1,3 +1,4 @@
+export const ProviderQuotaExceededFailureKind = 'provider-quota-exceeded';
 // inputTokens/outputTokens/cacheReadTokens/cacheWriteTokens/costUsd are the known
 // numeric keys agent-runner-adapter.ts writes into AgentRunResponse.metadata.
 export function agentTokenUsage(metadata) {

package/dist/src/execution/infrastructure/runners/claude.js

@@ -1,4 +1,5 @@
 import { ExternalExecutionKind } from '../../../activities/index.js';
+import { ProviderQuotaExceededFailureKind } from '../../contracts/runner.js';
 import { ExecutionCancellationReason, RunStatus } from '../../contracts/vocabulary.js';
 import { runProcess } from '../process-execution.js';
 export function createClaudeRunner(options = {}) {
@@ -6,6 +7,7 @@ export function createClaudeRunner(options = {}) {
         ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
         ...(options.model === undefined ? {} : { defaultModel: options.model }),
         parseSuccessfulOutput: parseClaudeOutput,
+        classifyFailure: classifyClaudeFailure,
         supportsSessionResume: true,
     });
 }
@@ -19,6 +21,20 @@ export function parseClaudeOutput(stdout, _request) {
         ...claudeUsage(value),
     };
 }
+// Deliberately narrow: only genuine provider usage/rate-limit phrasing.
+// Auth/login failures (unauthorized, authentication, permission denied, api
+// key) are NOT included here — they are a different failure class and must
+// not be paused-and-retried as if they were transient.
+const claudeQuotaPattern = /rate limit|quota|credit balance|spend limit|usage limit|session limit|too many requests|\b429\b/i;
+export function classifyClaudeFailure(input) {
+    // Prefer stderr — a CLI's own diagnostic stream — over stdout, which on a
+    // failed run can carry the agent's own generated text; only fall back to
+    // stdout when stderr is empty.
+    const text = input.stderr.trim().length > 0 ? input.stderr : input.stdout;
+    if (!claudeQuotaPattern.test(text))
+        return undefined;
+    return { kind: ProviderQuotaExceededFailureKind, message: text.trim() };
+}
 function claudeUsage(value) {
     const usage = record(value.usage);
     const input = usage === undefined ? undefined : numeric(usage.input_tokens);
@@ -98,20 +114,29 @@ export function cliRunner(name, command, args, options = {}) {
                         transport: RunStatus.Failed,
                         output: value.stdout,
                         runner: name,
-                        failure: {
-                            kind: value.timedOut
-                                ? ExecutionCancellationReason.Timeout
-                                : (value.failureKind ?? 'process-exit'),
-                            message: value.timedOut
-                                ? `Runner timed out after ${options.timeoutMs}ms`
-                                : (value.failureMessage ?? (value.stderr || `exit ${value.exitCode}`)),
-                        },
+                        failure: failureFor(value, options),
                     }),
                 cancel: process.cancel,
             };
         },
     };
 }
+function failureFor(value, options) {
+    if (value.timedOut)
+        return {
+            kind: ExecutionCancellationReason.Timeout,
+            message: `Runner timed out after ${options.timeoutMs}ms`,
+        };
+    if (value.failureKind !== undefined)
+        return {
+            kind: value.failureKind,
+            message: value.failureMessage ?? (value.stderr || `exit ${value.exitCode}`),
+        };
+    const classified = options.classifyFailure?.({ stdout: value.stdout, stderr: value.stderr });
+    if (classified !== undefined)
+        return classified;
+    return { kind: 'process-exit', message: value.stderr || `exit ${value.exitCode}` };
+}
 function parseSuccessfulOutput(stdout, request, parser) {
     if (parser === undefined)
         return {};

package/dist/src/execution/infrastructure/runners/codex.js

@@ -1,10 +1,47 @@
+import { ProviderQuotaExceededFailureKind } from '../../contracts/runner.js';
 import { WorkspaceMode } from '../../contracts/vocabulary.js';
 import { cliRunner } from './claude.js';
+// Deliberately narrow: only genuine provider usage/rate-limit phrasing.
+// Auth/login failures (unauthorized, authentication, api key, not logged
+// in, login required) are NOT included here — they are a different failure
+// class and must not be paused-and-retried as if they were transient.
+const codexQuotaPattern = /usage limit|rate limit|quota|too many requests|credit balance|spend limit|session limit|\b429\b/i;
+export function classifyCodexFailure(input) {
+    // Only ever classify from Codex's own structured error/turn.failed
+    // message, never from scanning raw stdout — stdout on a failed run can
+    // carry the agent's own generated text, which must never be
+    // pattern-matched into a false quota classification.
+    const structured = extractCodexErrorMessage(input.stdout);
+    if (structured === undefined)
+        return undefined;
+    if (!codexQuotaPattern.test(structured))
+        return undefined;
+    return { kind: ProviderQuotaExceededFailureKind, message: structured };
+}
+function extractCodexErrorMessage(stdout) {
+    for (const line of stdout.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        const event = parseLine(trimmed);
+        if (event === undefined)
+            continue;
+        if (event.type === 'error' && typeof event.message === 'string')
+            return event.message;
+        if (event.type === 'turn.failed') {
+            const error = asRecord(event.error);
+            if (typeof error?.message === 'string')
+                return error.message;
+        }
+    }
+    return undefined;
+}
 export function createCodexRunner(options = {}) {
     return cliRunner('codex', options.command ?? 'codex', (request) => codexCommandArgs(request, options.args, options), {
         ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
         ...(options.model === undefined ? {} : { defaultModel: options.model }),
         parseSuccessfulOutput: parseCodexOutput,
+        classifyFailure: classifyCodexFailure,
         supportsSessionResume: true,
     });
 }

package/dist/src/execution/infrastructure/runners/cursor.js

@@ -1,12 +1,27 @@
+import { ProviderQuotaExceededFailureKind } from '../../contracts/runner.js';
 import { WorkspaceMode } from '../../contracts/vocabulary.js';
 import { cliRunner } from './claude.js';
 // Cursor's CLI subcommand, not the closed domain vocabulary word "agent".
 const cursorCliSubcommand = String.fromCharCode(97, 103, 101, 110, 116);
+// Deliberately narrow: only genuine provider usage/rate-limit phrasing.
+// Auth/login failures (unauthorized, authentication, api key) are NOT
+// included here — they are a different failure class and must not be
+// paused-and-retried as if they were transient.
+const cursorQuotaPattern = /rate limit|usage limit|quota|credit balance|spend limit|session limit|too many requests|\b429\b/i;
+export function classifyCursorFailure(input) {
+    // Prefer stderr over stdout, same reasoning as Claude's classifier: stdout
+    // on a failed run can carry the agent's own generated text.
+    const text = input.stderr.trim().length > 0 ? input.stderr : input.stdout;
+    if (!cursorQuotaPattern.test(text))
+        return undefined;
+    return { kind: ProviderQuotaExceededFailureKind, message: text.trim() };
+}
 export function createCursorRunner(options = {}) {
     return cliRunner('cursor', options.command ?? 'cursor', (request) => cursorCommandArgs(request, options.args, options), {
         ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
         ...(options.model === undefined ? {} : { defaultModel: options.model }),
         parseSuccessfulOutput: parseCursorOutput,
+        classifyFailure: classifyCursorFailure,
         supportsSessionResume: true,
     });
 }

package/dist/src/execution/infrastructure/runners/registry.js

@@ -1,3 +1,11 @@
+export class NoEligibleRunnerError extends Error {
+    runnerPool;
+    constructor(runnerPool) {
+        super(`Execution runner pool ${runnerPool} has no eligible runner: all candidates are ineligible`);
+        this.runnerPool = runnerPool;
+        this.name = 'NoEligibleRunnerError';
+    }
+}
 export class RunnerRegistry {
     runnerPools;
     runners;
@@ -22,5 +30,5 @@ function selectEligibleCandidate(runnerPool, candidates, runners, ineligible) {
             throw new Error(`Runner ${name} is not registered`);
         return { name, runner };
     }
-    throw new Error(`Execution runner pool ${runnerPool} has no eligible runner: all candidates are ineligible`);
+    throw new NoEligibleRunnerError(runnerPool);
 }

package/dist/src/integrations/delivery/application/delivery-outcome-reactor.js

@@ -1,34 +1,63 @@
 import { ActivityOutcomeKind, activationId } from '../../../activities/index.js';
-import { EventActorKind } from '../../../kernel/index.js';
+import { EventActorKind, } from '../../../kernel/index.js';
 import { ActivityActivationStatus, workflowInstanceId, } from '../../../orchestration/index.js';
 import { DeliveryEventType, selectDeliveryEvent } from '../contracts/events.js';
 import { DeliveryResultKind } from '../contracts/vocabulary.js';
 const deliveryResultSignalKind = 'delivery-result';
+const pendingNamespace = 'reactor:delivery-outcomes:pending';
+const pendingKey = 'pending-confirmations';
 export class DeliveryOutcomeReactor {
     journal;
     checkpoints;
     orchestration;
-    constructor(journal, checkpoints, orchestration) {
+    projections;
+    constructor(journal, checkpoints, orchestration, projections) {
         this.journal = journal;
         this.checkpoints = checkpoints;
         this.orchestration = orchestration;
+        this.projections = projections;
     }
     async runOnce() {
         const consumer = 'reactor:delivery-outcomes';
         const events = await this.journal.readAll(await this.checkpoints.load(consumer));
-        const resolvedDeliveryEventIds = new Set();
+        const resolved = new Set();
+        const pending = new Map((await this.loadPending()).map((event) => [event.eventId, event]));
         for (const event of events) {
-            await this.reconcile(event, resolvedDeliveryEventIds);
+            const matched = await this.reconcile(event, resolved);
+            if (matched === false) {
+                // reconcile() only ever returns false for a delivery-terminal event
+                // (selectDeliveryEvent(event) !== null), so this lookup can't miss.
+                const delivery = selectDeliveryEvent(event);
+                pending.set(delivery.eventId, event);
+            }
             await this.checkpoints.save(consumer, event.globalPosition);
         }
-        for (const event of await this.journal.readAll(0))
-            await this.reconcile(event, resolvedDeliveryEventIds);
+        // Catches a confirmation checkpointed before its workflow reached
+        // "waiting for delivery" — re-checked here on every call rather than
+        // relying on the incremental pass above, which never revisits a
+        // position once checkpointed.
+        for (const [id, pendingEvent] of pending) {
+            if (resolved.has(id)) {
+                pending.delete(id);
+                continue;
+            }
+            const matched = await this.reconcile(pendingEvent, resolved);
+            if (matched === true)
+                pending.delete(id);
+        }
+        await this.savePending([...pending.values()]);
         return events.length;
     }
+    // true: resolved (accepted this call, or already accepted earlier this
+    // same call). false: a delivery-terminal event whose workflow isn't
+    // waiting on it yet — belongs in the pending set for a later retry. null:
+    // not a delivery-terminal event at all.
     async reconcile(event, seen) {
         const delivery = selectDeliveryEvent(event);
-        if (delivery === null || seen.has(delivery.eventId))
-            return;
+        if (delivery === null)
+            return null;
+        if (seen.has(delivery.eventId))
+            return true;
         const outcome = delivery.eventType === DeliveryEventType.Confirmed ||
             (delivery.eventType === DeliveryEventType.Reconciled &&
                 delivery.payload.result === DeliveryResultKind.Confirmed)
@@ -37,13 +66,13 @@ export class DeliveryOutcomeReactor {
                 ? { kind: ActivityOutcomeKind.Failed, data: { reason: delivery.payload.code } }
                 : null;
         if (outcome === null)
-            return;
+            return null;
         const command = {
             workflowInstanceId: workflowInstanceId(delivery.payload.workflowInstanceId),
             activationId: activationId(delivery.payload.activationId),
         };
         if (!(await this.isAwaitingThisDelivery(command, delivery.payload.intentEventId)))
-            return;
+            return false;
         seen.add(delivery.eventId);
         await this.orchestration.acceptOutcome({ ...command, outcome }, {
             commandId: delivery.eventId,
@@ -51,6 +80,7 @@ export class DeliveryOutcomeReactor {
             actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
             occurredAt: event.recordedAt,
         });
+        return true;
     }
     /**
      * A delivery's own completion may only resolve the activation that
@@ -66,4 +96,16 @@ export class DeliveryOutcomeReactor {
             view.waitingFor?.signalKind === deliveryResultSignalKind &&
             view.waitingFor.intentEventId === intentEventId);
     }
+    async loadPending() {
+        const stored = await this.projections.read(pendingNamespace, pendingKey);
+        return stored?.value.events ?? [];
+    }
+    async savePending(events) {
+        await this.projections.write({
+            namespace: pendingNamespace,
+            key: pendingKey,
+            lastGlobalPosition: 0,
+            value: { events },
+        });
+    }
 }

package/dist/src/kernel/contracts/journal-change-signal.js

@@ -0,0 +1 @@
+export {};

package/dist/src/kernel/index.js

@@ -5,6 +5,7 @@ export * from './contracts/event-journal.js';
 export * from './contracts/event-schema.js';
 export * from './contracts/events.js';
 export * from './contracts/id-generator.js';
+export * from './contracts/journal-change-signal.js';
 export { causationId, correlationId, eventId } from './contracts/identifiers.js';
 export * from './contracts/projection-store.js';
 export * from './contracts/relations.js';
@@ -14,5 +15,6 @@ export * from './domain/event-envelope.js';
 export * from './domain/match-mode.js';
 export * from './domain/relation.js';
 export * from './infrastructure/cached-journal-view.js';
+export * from './infrastructure/journal-change-signal.js';
 export * from './infrastructure/system-clock.js';
 export * from './infrastructure/ulid-id-generator.js';

package/dist/src/kernel/infrastructure/journal-change-signal.js

@@ -0,0 +1,30 @@
+export class InProcessJournalChangeSignal {
+    waiters = [];
+    notify() {
+        const waiters = this.waiters;
+        this.waiters = [];
+        for (const resolve of waiters)
+            resolve();
+    }
+    waitForChange(signal, fallbackMs) {
+        if (signal.aborted)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            let settled = false;
+            const done = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                signal.removeEventListener('abort', done);
+                // Must drop this waiter here too, not just in notify() — otherwise
+                // every timeout/abort leaks an entry into `waiters` forever.
+                this.waiters = this.waiters.filter((waiter) => waiter !== done);
+                resolve();
+            };
+            this.waiters.push(done);
+            const timer = setTimeout(done, fallbackMs);
+            signal.addEventListener('abort', done, { once: true });
+        });
+    }
+}

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

@@ -3,7 +3,7 @@ import { OrchestrationEventType } from '../contracts/events.js';
 import { commandName, workflowInstanceId, } from '../contracts/identifiers.js';
 import { workflowInstanceStream } from '../contracts/streams.js';
 import { WorkflowStatus } from '../contracts/vocabulary.js';
-import { requestChangesResume as decideChangesResume, requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, } from '../domain/interpreter.js';
+import { requestChangesResume as decideChangesResume, requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, requestRunnerQuotaRetry, } from '../domain/interpreter.js';
 import { isAuthorisedActor } from '../domain/supplemental-policy.js';
 import { appendWithIntentRecovery } from './durable-append.js';
 import { acceptResourceTransition, matchResourceTransitions, } from './resource-transition-matching.js';
@@ -112,6 +112,29 @@ export class AdvanceWorkflow {
         ]);
         return (await this.repository.load(id)).view;
     }
+    async retryRunnerQuotaFailure(id, input, context) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null)
+            return null;
+        // The retry re-requests the interrupted Activation, not a stage lookup, but
+        // the definition must still be resolvable for the retried Activation's own
+        // outcome to be routable later; an unavailable definition blocks here.
+        const definition = await this.workflows.definitionForOperation(loaded.view, loaded.sequence, context);
+        if (definition === null)
+            return (await this.repository.loadRequired(id)).view;
+        const decision = requestRunnerQuotaRetry(loaded.view, {
+            activationId: input.activationId,
+            runId: input.runId,
+            runnerName: input.runnerName,
+            message: input.message,
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        if (decision.kind === 'ignored')
+            return loaded.view;
+        await this.repository.append(id, loaded.sequence, decision.events);
+        return (await this.repository.load(id)).view;
+    }
     async retryBlockedFailedStage(id, context) {
         const loaded = await this.repository.load(id);
         if (loaded.view === null)

package/dist/src/orchestration/application/orchestration-service.js

@@ -67,6 +67,9 @@ export class OrchestrationService {
     resolveExecutionFailure(workflowInstanceId, input, context) {
         return this.transitionWatchChildren(context, () => this.advanceWorkflow.resolveExecutionFailure(workflowInstanceId, input, context));
     }
+    retryRunnerQuotaFailure(workflowInstanceId, input, context) {
+        return this.transitionWatchChildren(context, () => this.advanceWorkflow.retryRunnerQuotaFailure(workflowInstanceId, input, context));
+    }
     retryBlockedFailedStage(workflowInstanceId, context) {
         return this.transitionWatchChildren(context, () => this.advanceWorkflow.retryBlockedFailedStage(workflowInstanceId, context));
     }

package/dist/src/orchestration/contracts/event-decoder.js

@@ -232,6 +232,14 @@ const eventSchema = z.discriminatedUnion('eventType', [
         reason: z.string().min(1),
     })
         .strict()),
+    workflowEnvelope(OrchestrationEventType.ActivityRetriedForRunnerQuota, z
+        .object({
+        activationId: brandedStringSchema(activationId),
+        runId: z.string().min(1),
+        runnerName: z.string().min(1),
+        message: z.string().min(1),
+    })
+        .strict()),
     workflowEnvelope(OrchestrationEventType.ActivityWaiting, z
         .object({
         activationId: brandedStringSchema(activationId),

package/dist/src/orchestration/contracts/events.js

@@ -7,6 +7,7 @@ export const OrchestrationEventType = {
     ActivityStarted: 'orchestration.activity-started',
     ActivityOutcomeAccepted: 'orchestration.activity-outcome-accepted',
     ActivityExecutionFailed: 'orchestration.activity-execution-failed',
+    ActivityRetriedForRunnerQuota: 'orchestration.activity-retried-for-runner-quota',
     ActivityWaiting: 'orchestration.activity-waiting',
     SignalWaitStarted: 'orchestration.signal-wait-started',
     SignalAccepted: 'orchestration.signal-accepted',

package/dist/src/orchestration/domain/interpreter.js

@@ -11,6 +11,7 @@ export { startInstance } from './activation-policy.js';
 export { acceptSignal, waitForSignal } from './signal-policy.js';
 export { requestSupplementalActivity } from './supplemental-policy.js';
 export { isChangesResumeEligible, isOperatorRetryEligible, requestChangesResume, requestOperatorRetry, selectOperatorRetryTarget, } from './operator-retry-policy.js';
+export { isRunnerQuotaRetryEligible, requestRunnerQuotaRetry, } from './runner-quota-retry-policy.js';
 export function acceptActivityOutcome(definition, state, input) {
     if (!isPendingOutcome(state, input))
         return { kind: 'ignored', reason: 'outcome is not for the pending activation' };

package/dist/src/orchestration/domain/runner-quota-retry-policy.js

@@ -0,0 +1,41 @@
+import { activationId as toActivationId } from '../../activities/index.js';
+import { OrchestrationEventType, } from '../contracts/events.js';
+import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+export function isRunnerQuotaRetryEligible(view, activationId) {
+    return (view.pendingActivation?.activationId === activationId &&
+        !view.acceptedOutcomes.includes(toActivationId(activationId)));
+}
+export function requestRunnerQuotaRetry(state, input) {
+    if (!isRunnerQuotaRetryEligible(state, input.activationId))
+        return {
+            kind: 'ignored',
+            reason: 'workflow has no matching pending activation for runner-quota retry',
+        };
+    // Re-request the interrupted Activation itself, not the current stage's
+    // configured activity: a supplemental or follow-on Activation runs a
+    // different activity and input, and substituting the stage's main one would
+    // drop that work and re-run something the runner never attempted.
+    const interrupted = state.pendingActivation;
+    // No RetryCounted here, deliberately: a quota condition is a runner-capacity
+    // fact, not a failed attempt, so it must never consume the route's
+    // configured `retry.max` budget.
+    const events = [
+        stateDraft(state, input, OrchestrationEventType.ActivityRetriedForRunnerQuota, {
+            activationId: toActivationId(input.activationId),
+            runId: input.runId,
+            runnerName: input.runnerName,
+            message: input.message,
+        }, 1),
+        stateDraft(state, input, OrchestrationEventType.ActivityRequested, activation(state.workflowInstanceId, nextOrdinal(state), interrupted.activity, interrupted.input, {
+            execution: interrupted.execution,
+            ...(interrupted.stage === undefined ? {} : { stage: interrupted.stage }),
+            ...(interrupted.followOnIndex === undefined
+                ? {}
+                : { followOnIndex: interrupted.followOnIndex }),
+            ...(interrupted.supplemental === undefined
+                ? {}
+                : { supplemental: interrupted.supplemental }),
+        }), 2),
+    ];
+    return { kind: 'append', events };
+}

package/dist/src/orchestration/domain/workflow-instance-events.js

@@ -34,6 +34,7 @@ function isActivityFact(event) {
         case OrchestrationEventType.ActivityStarted:
         case OrchestrationEventType.ActivityOutcomeAccepted:
         case OrchestrationEventType.ActivityExecutionFailed:
+        case OrchestrationEventType.ActivityRetriedForRunnerQuota:
         case OrchestrationEventType.ActivityWaiting:
             return true;
         default:
@@ -61,6 +62,10 @@ function applyActivityFact(state, event) {
             state.executionFailure = event.payload;
             updateActivationStatus(state, event.payload.activationId, ActivityActivationStatus.Completed);
             return;
+        case OrchestrationEventType.ActivityRetriedForRunnerQuota:
+            state.acceptedOutcomes.push(event.payload.activationId);
+            updateActivationStatus(state, event.payload.activationId, ActivityActivationStatus.Completed);
+            return;
         case OrchestrationEventType.ActivityWaiting:
             applyActivityWaiting(state, event);
             return;

package/dist/src/persistence/filesystem/file-event-journal.js

@@ -1,7 +1,7 @@
 import { appendFile, mkdir, readdir, readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
-import { decodeEventEnvelope, WrongExpectedSequenceError } from '../../kernel/index.js';
+import { decodeEventEnvelope, InProcessJournalChangeSignal, WrongExpectedSequenceError, } from '../../kernel/index.js';
 import { withFileLock } from './file-lock.js';
 export class FileEventJournal {
     root;
@@ -10,6 +10,10 @@ export class FileEventJournal {
         this.root = root;
         this.clock = clock;
     }
+    changeSignalSource = new InProcessJournalChangeSignal();
+    get changeSignal() {
+        return this.changeSignalSource;
+    }
     cached;
     async append(stream, expectedSequence, drafts) {
         return withFileLock(join(this.root, 'locks', 'event-journal.lock'), async () => {
@@ -56,6 +60,7 @@ export class FileEventJournal {
                 const file = `${day}.jsonl`;
                 await appendFile(join(directory, file), newEnvelopes.map((event) => JSON.stringify(event)).join('\n') + '\n', 'utf8');
                 await this.extendCache(file, current, newEnvelopes);
+                this.changeSignalSource.notify();
             }
             return finalizedEnvelopes;
         });

package/dist/src/persistence/memory/in-memory-event-journal.js

@@ -1,13 +1,17 @@
 import { isDeepStrictEqual } from 'node:util';
-import { WrongExpectedSequenceError } from '../../kernel/index.js';
+import { InProcessJournalChangeSignal, WrongExpectedSequenceError } from '../../kernel/index.js';
 export class InMemoryEventJournal {
     clock;
     streams = new Map();
     events = [];
     eventIds = new Map();
+    changeSignalSource = new InProcessJournalChangeSignal();
     constructor(clock) {
         this.clock = clock;
     }
+    get changeSignal() {
+        return this.changeSignalSource;
+    }
     async append(stream, expectedSequence, events) {
         validateBatch(stream, events);
         const existingEvents = events.map((draft) => this.eventIds.get(draft.eventId));
@@ -21,6 +25,7 @@ export class InMemoryEventJournal {
         }
         const recordedAt = this.clock.now().toISOString();
         const appended = [];
+        let newCount = 0;
         for (const [index, draft] of events.entries()) {
             const prior = existingEvents[index];
             if (prior !== undefined) {
@@ -37,8 +42,11 @@ export class InMemoryEventJournal {
             this.events.push(envelope);
             this.eventIds.set(draft.eventId, { draft, envelope });
             appended.push(envelope);
+            newCount += 1;
         }
         this.streams.set(streamKey(stream), streamEvents);
+        if (newCount > 0)
+            this.changeSignalSource.notify();
         return appended;
     }
     async readStream(stream) {

package/package.json

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