@atolis-hq/wake 0.2.53 → 0.2.54

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

@@ -493,6 +493,25 @@ export function createTickRunner(deps) {
     function runnerTimeoutMs() {
         return maxConfiguredRunnerTimeoutMs(deps.config);
     }
+    // Counted from durable run records (never an in-memory counter, per the
+    // "tick is a pure function of durable state" invariant), so this holds
+    // across process restarts and is a backstop independent of any specific
+    // dispatch-eligibility bug (stuck watcher, misconfigured cron, a dedupe gap
+    // not yet caught) - it caps total damage rather than preventing a cause.
+    async function exceedsDispatchRateLimit(now) {
+        const { windowMs, maxDispatches } = deps.config.scheduler.dispatchRateLimit;
+        const windowStartMs = now.getTime() - windowMs;
+        const runRecords = await deps.stateStore.listRunRecords();
+        const recentCount = runRecords.reduce((count, record) => {
+            const startedAtMs = Date.parse(record.startedAt);
+            return Number.isFinite(startedAtMs) &&
+                startedAtMs >= windowStartMs &&
+                startedAtMs <= now.getTime()
+                ? count + 1
+                : count;
+        }, 0);
+        return recentCount >= maxDispatches;
+    }
     function cancellationReasonForIneligibleProjection(projection) {
         if (projection === null || projection.issue.state !== 'open') {
             return 'CANCELED_BY_SOURCE_CLOSED';
@@ -710,6 +729,15 @@ export function createTickRunner(deps) {
     }
     async function nextWatcherDispatch(projections, now) {
         for (const projection of projections) {
+            // A closed issue can still carry a stale status label (e.g. squash-merged
+            // outside Wake's own merge gate, before label reconciliation caught up),
+            // so this must be checked explicitly - unlike deriveWatchlist and
+            // cancellationReasonForIneligibleProjection, watcher dispatch has no
+            // other path that excludes closed issues. Without this, a closed issue
+            // whose last-seen local status matches `watcher.while.status` (e.g.
+            // awaiting-approval) re-fires its watcher workflow every tick forever.
+            if (projection.issue.state !== 'open')
+                continue;
             const parentWorkflow = workflowForProjection(projection, deps.config);
             if (parentWorkflow === null)
                 continue;
@@ -862,6 +890,33 @@ export function createTickRunner(deps) {
             if (candidate === undefined) {
                 return { status: 'idle' };
             }
+            if (await exceedsDispatchRateLimit(tickStartedAt)) {
+                const rateLimitedWorkflowName = workflowNameForProjection(candidate, deps.config);
+                const rateLimitedWorkflow = workflowForProjection(candidate, deps.config);
+                const blockedAt = eventStampNow();
+                await appendAuditEvent({
+                    eventId: `dispatch-rate-limited-${candidate.workItemKey}-${tickStartedAt.getTime()}`,
+                    decisionType: 'dispatch.rate-limited',
+                    workItemKey: candidate.workItemKey,
+                    runId: `dispatch-rate-limited-${candidate.workItemKey}-${tickStartedAt.getTime()}`,
+                    workflowRevision: rateLimitedWorkflow === null
+                        ? 'sha256:unavailable'
+                        : await computeWorkflowRevision({
+                            config: deps.config,
+                            workflowName: rateLimitedWorkflowName,
+                            workflow: rateLimitedWorkflow,
+                        }),
+                    inputsConsidered: {
+                        windowMs: deps.config.scheduler.dispatchRateLimit.windowMs,
+                        maxDispatches: deps.config.scheduler.dispatchRateLimit.maxDispatches,
+                        watcherRun,
+                    },
+                    outcome: { dispatched: false, reason: 'dispatch-rate-limit-exceeded' },
+                    timestamp: blockedAt,
+                    sourceRefs: { repo: candidate.issue.repo, issueNumber: candidate.issue.number },
+                });
+                return { status: 'idle' };
+            }
             let sourceRevision = projectedSourceRevision(candidate);
             let refresh;
             try {

package/dist/src/domain/schema.js

@@ -597,8 +597,27 @@ const wakeConfigBaseSchema = z.object({
             .int()
             .positive()
             .default(5 * 60 * 1000),
+        // Deterministic circuit breaker independent of any specific dispatch-eligibility
+        // bug: caps total runner invocations (main path + watchers) in a trailing
+        // window, counted from durable run records, not in-memory state. A storm
+        // (stuck watcher, misconfigured cron, dedupe bug) hits this ceiling and idles
+        // instead of compounding cost indefinitely.
+        dispatchRateLimit: z
+            .object({
+            windowMs: z
+                .number()
+                .int()
+                .positive()
+                .default(60 * 60 * 1000),
+            maxDispatches: z.number().int().positive().default(20),
+        })
+            .default({ windowMs: 60 * 60 * 1000, maxDispatches: 20 }),
     })
-        .default({ intervalMs: 60 * 1000, maxIntervalMs: 5 * 60 * 1000 }),
+        .default({
+        intervalMs: 60 * 1000,
+        maxIntervalMs: 5 * 60 * 1000,
+        dispatchRateLimit: { windowMs: 60 * 60 * 1000, maxDispatches: 20 },
+    }),
     transcripts: z
         .object({
         enabled: z.boolean().default(false),

package/dist/src/version.js

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

package/package.json

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