@atolis-hq/wake 0.2.52 → 0.2.54

package/dist/src/adapters/fake/fake-workspace-manager.js

@@ -1,17 +1,71 @@
 import { mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-export function createFakeWorkspaceManager(root) {
+export class FakeWorkspaceValidationError extends Error {
+    failureSource = 'wake-workspace-validation';
+    constructor(message) {
+        super(message);
+        this.name = 'FakeWorkspaceValidationError';
+    }
+}
+export function createFakeWorkspaceManager(root, options = {}) {
+    function validation(input) {
+        if (options.failValidation === true) {
+            throw new FakeWorkspaceValidationError('fake workspace validation failed');
+        }
+        return {
+            repo: input.repo,
+            expectedBranch: input.branch,
+            actualBranch: input.branch,
+            expectedRemoteUrl: input.remoteUrl,
+            actualRemoteUrl: input.remoteUrl,
+            baseRevision: 'fake-base',
+            headRevision: 'fake-head',
+            clean: true,
+            remoteAvailable: true,
+        };
+    }
     return {
-        async prepareWorkspace({ workId }) {
+        async prepareWorkspace({ workId, repo, issueNumber, }) {
             // Keyed on the work id, symmetrically with the real git-backed manager.
             const workspacePath = join(root, workId);
             await mkdir(workspacePath, { recursive: true });
-            return { workspacePath, mergeConflictDetected: false };
+            return {
+                workspacePath,
+                mergeConflictDetected: false,
+                validation: validation({
+                    repo,
+                    branch: `wake/issue-${issueNumber}`,
+                    remoteUrl: `https://github.com/${repo}.git`,
+                }),
+            };
         },
         async prepareReadOnlyClone({ repo }) {
             const workspacePath = join(root, repo.replace(/[\\/]/g, '__'), 'canonical');
             await mkdir(workspacePath, { recursive: true });
-            return { workspacePath };
+            return {
+                workspacePath,
+                validation: validation({
+                    repo,
+                    branch: 'main',
+                    remoteUrl: `https://github.com/${repo}.git`,
+                }),
+            };
+        },
+        async recordWorkspaceBookkeeping() {
+            if (options.failBookkeeping === true) {
+                throw new Error('fake workspace bookkeeping failed');
+            }
+            return {
+                branch: 'wake/issue-fake',
+                headRevision: 'fake-head-after-run',
+                diffSummary: '',
+                untrackedFiles: [],
+                unpushedCommits: {
+                    hasUpstream: false,
+                    count: 0,
+                    commits: [],
+                },
+            };
         },
         async cleanupWorkspace({ workspacePath }) {
             // Retry on Windows EBUSY/EPERM (AV/indexer holding a brief handle) to

package/dist/src/adapters/git/git-workspace-manager.js

@@ -19,6 +19,28 @@ async function git(args, cwd) {
     });
     return { stdout: result.stdout.trim(), stderr: result.stderr.trim() };
 }
+async function gitExitCode(args, cwd) {
+    try {
+        await execFile('git', args, {
+            cwd,
+            env: process.env,
+            encoding: 'utf8',
+            maxBuffer: 1024 * 1024 * 16,
+        });
+        return 0;
+    }
+    catch (error) {
+        const maybeExit = error;
+        return typeof maybeExit.code === 'number' ? maybeExit.code : 1;
+    }
+}
+export class WorkspaceValidationError extends Error {
+    failureSource = 'wake-workspace-validation';
+    constructor(message) {
+        super(message);
+        this.name = 'WorkspaceValidationError';
+    }
+}
 async function detectDefaultBranch(repoPath) {
     await git(['remote', 'set-head', 'origin', '--auto'], repoPath);
     const { stdout } = await git(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], repoPath);
@@ -95,6 +117,76 @@ async function tryUpdateFromDefaultBranch(workspacePath) {
         return { mergeConflictDetected: false };
     }
 }
+async function validateWorkspace(input) {
+    await git(['fetch', 'origin'], input.workspacePath);
+    const { stdout: actualRemoteUrl } = await git(['remote', 'get-url', 'origin'], input.workspacePath);
+    const { stdout: actualBranch } = await git(['rev-parse', '--abbrev-ref', 'HEAD'], input.workspacePath);
+    const { stdout: baseRevision } = await git(['merge-base', 'HEAD', input.expectedBaseRef], input.workspacePath);
+    const { stdout: headRevision } = await git(['rev-parse', 'HEAD'], input.workspacePath);
+    const { stdout: status } = await git(['status', '--porcelain'], input.workspacePath);
+    const remoteExit = await gitExitCode(['ls-remote', '--exit-code', 'origin', 'HEAD'], input.workspacePath);
+    const validation = {
+        repo: input.repo,
+        expectedBranch: input.expectedBranch,
+        actualBranch,
+        expectedRemoteUrl: input.expectedRemoteUrl,
+        actualRemoteUrl,
+        baseRevision,
+        headRevision,
+        clean: status.length === 0,
+        remoteAvailable: remoteExit === 0,
+    };
+    const failures = [];
+    if (actualRemoteUrl !== input.expectedRemoteUrl) {
+        failures.push(`expected origin ${input.expectedRemoteUrl}, found ${actualRemoteUrl}`);
+    }
+    if (actualBranch !== input.expectedBranch) {
+        failures.push(`expected branch ${input.expectedBranch}, found ${actualBranch}`);
+    }
+    if (!validation.clean) {
+        failures.push('working tree has uncommitted or untracked changes');
+    }
+    if (!validation.remoteAvailable) {
+        failures.push('origin remote is not available');
+    }
+    if (failures.length > 0) {
+        throw new WorkspaceValidationError(`Workspace validation failed: ${failures.join('; ')}`);
+    }
+    return validation;
+}
+async function recordWorkspaceBookkeeping(workspacePath) {
+    const { stdout: branch } = await git(['rev-parse', '--abbrev-ref', 'HEAD'], workspacePath);
+    const { stdout: headRevision } = await git(['rev-parse', 'HEAD'], workspacePath);
+    const { stdout: diffSummary } = await git(['diff', '--stat', 'HEAD'], workspacePath);
+    const { stdout: untracked } = await git(['ls-files', '--others', '--exclude-standard'], workspacePath);
+    let hasUpstream = true;
+    let count;
+    let commits;
+    try {
+        const { stdout: upstream } = await git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], workspacePath);
+        const { stdout: ahead } = await git(['rev-list', '--count', `${upstream}..HEAD`], workspacePath);
+        count = parseInt(ahead, 10);
+        const { stdout: commitLog } = await git(['log', '--pretty=format:%h %s', `${upstream}..HEAD`], workspacePath);
+        commits = commitLog.length === 0 ? [] : commitLog.split('\n');
+    }
+    catch {
+        hasUpstream = false;
+        const { stdout: commitLog } = await git(['log', '--pretty=format:%h %s'], workspacePath);
+        commits = commitLog.length === 0 ? [] : commitLog.split('\n');
+        count = commits.length;
+    }
+    return {
+        branch,
+        headRevision,
+        diffSummary,
+        untrackedFiles: untracked.length === 0 ? [] : untracked.split('\n'),
+        unpushedCommits: {
+            hasUpstream,
+            count,
+            commits,
+        },
+    };
+}
 export function createGitWorkspaceManager(options) {
     const paths = createWakePaths(options.wakeRoot);
     const remoteUrlForRepo = options.remoteUrlForRepo ?? defaultRemoteUrlForRepo;
@@ -131,7 +223,15 @@ export function createGitWorkspaceManager(options) {
             const workspacePath = paths.workspaceDir(workId);
             if (await pathExists(workspacePath)) {
                 const updateResult = await tryUpdateFromDefaultBranch(workspacePath);
-                return { workspacePath, ...updateResult };
+                const defaultBranch = await detectDefaultBranch(workspacePath);
+                const validation = await validateWorkspace({
+                    workspacePath,
+                    repo,
+                    expectedBranch: branchNameForIssue(issueNumber),
+                    expectedRemoteUrl: remoteUrlForRepo(repo),
+                    expectedBaseRef: `origin/${defaultBranch}`,
+                });
+                return { workspacePath, ...updateResult, validation };
             }
             const { repoPath, defaultBranch } = await ensureCanonicalClone(repo);
             const remoteUrl = remoteUrlForRepo(repo);
@@ -144,14 +244,32 @@ export function createGitWorkspaceManager(options) {
             const branch = branchNameForIssue(issueNumber);
             await git(['remote', 'set-url', 'origin', remoteUrl], workspacePath);
             await git(['checkout', '-B', branch], workspacePath);
-            return { workspacePath, mergeConflictDetected: false };
+            const validation = await validateWorkspace({
+                workspacePath,
+                repo,
+                expectedBranch: branch,
+                expectedRemoteUrl: remoteUrl,
+                expectedBaseRef: `origin/${defaultBranch}`,
+            });
+            return { workspacePath, mergeConflictDetected: false, validation };
         },
-        async prepareReadOnlyClone({ repo }) {
+        async prepareReadOnlyClone({ repo, }) {
             // Refine only reads the issue and, at most, the canonical clone -
             // it never gets a per-issue branch/workspace of its own (only
             // 'implement' pays that cost).
             const { repoPath } = await ensureCanonicalClone(repo);
-            return { workspacePath: repoPath };
+            const defaultBranch = await detectDefaultBranch(repoPath);
+            const validation = await validateWorkspace({
+                workspacePath: repoPath,
+                repo,
+                expectedBranch: defaultBranch,
+                expectedRemoteUrl: remoteUrlForRepo(repo),
+                expectedBaseRef: `origin/${defaultBranch}`,
+            });
+            return { workspacePath: repoPath, validation };
+        },
+        async recordWorkspaceBookkeeping({ workspacePath, }) {
+            return recordWorkspaceBookkeeping(workspacePath);
         },
         async cleanupWorkspace({ workspacePath }) {
             // On Windows, a just-exited git subprocess (or AV/indexer) can hold a brief

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

@@ -56,6 +56,9 @@ function hasConfirmedExternalSideEffect(projection) {
     return projection.correlatedResources.some((resource) => /^[a-z0-9-]+:pr:/.test(resource.resourceUri));
 }
 function failurePhaseForRecord(record) {
+    if (record.metadata?.failureSource === 'wake-workspace-validation') {
+        return 'workspace-validation';
+    }
     if (record.agentPid !== undefined || record.agentProcessStartedAt !== undefined) {
         return 'running';
     }
@@ -67,6 +70,12 @@ function failurePhaseForRecord(record) {
     }
     return 'unknown';
 }
+function isWorkspaceValidationFailure(error) {
+    return (error !== null &&
+        typeof error === 'object' &&
+        'failureSource' in error &&
+        error.failureSource === 'wake-workspace-validation');
+}
 function classifyFailedRun(input) {
     const processStarted = input.record.agentPid !== undefined || input.record.agentProcessStartedAt !== undefined;
     const workspaceChanged = input.workspacePath !== undefined;
@@ -484,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';
@@ -701,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;
@@ -853,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 {
@@ -1269,6 +1333,9 @@ export function createTickRunner(deps) {
                         ...preparedRecord.metadata,
                         ...(workspacePath === undefined ? {} : { workspacePath }),
                         workspaceMode,
+                        ...(prepareResult.validation === undefined
+                            ? {}
+                            : { workspaceValidation: prepareResult.validation }),
                     },
                 });
                 const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
@@ -1398,6 +1465,22 @@ export function createTickRunner(deps) {
                     ? null
                     : lifecycle.nextStageFromSentinel(claimedStage, sentinel, workflow);
                 const finishedAt = deps.clock.now().toISOString();
+                let workspaceBookkeeping;
+                if (workspacePath !== undefined) {
+                    try {
+                        workspaceBookkeeping = {
+                            status: 'recorded',
+                            result: await deps.workspaceManager.recordWorkspaceBookkeeping({ workspacePath }),
+                        };
+                    }
+                    catch (error) {
+                        workspaceBookkeeping = {
+                            status: 'failed',
+                            failureSource: 'wake-workspace-bookkeeping',
+                            error: error instanceof Error ? error.message : String(error),
+                        };
+                    }
+                }
                 let prReviewTargetResourceUri = null;
                 if (watcherRun) {
                     // Artifact correlation is intentionally scoped to any watcher-dispatched
@@ -1543,6 +1626,7 @@ export function createTickRunner(deps) {
                     ...(runnerResult.tokenUsage === undefined ? {} : { tokenUsage: runnerResult.tokenUsage }),
                     metadata: {
                         ...finalisingRecord.metadata,
+                        ...(workspaceBookkeeping === undefined ? {} : { workspaceBookkeeping }),
                         ...resultMetadata,
                     },
                 });
@@ -1680,6 +1764,9 @@ export function createTickRunner(deps) {
                     projection: candidate,
                     record: failedRecord,
                     failureClass: 'infra',
+                    ...(isWorkspaceValidationFailure(err)
+                        ? { failurePhase: 'workspace-validation' }
+                        : {}),
                     ...(failedRecordWorkspacePath === undefined
                         ? {}
                         : { workspacePath: failedRecordWorkspacePath }),
@@ -1696,6 +1783,9 @@ export function createTickRunner(deps) {
                     metadata: {
                         ...failedRecord.metadata,
                         failureClass: 'infra',
+                        ...(isWorkspaceValidationFailure(err)
+                            ? { failureSource: 'wake-workspace-validation' }
+                            : {}),
                         ...failureContext,
                     },
                 });

package/dist/src/domain/schema.js

@@ -327,6 +327,7 @@ const runLeaseSchema = z.object({
     expiresAt: isoTimestampSchema,
 });
 export const failurePhaseSchema = z.enum([
+    'workspace-validation',
     'workspace-prep',
     'process-starting',
     'running',
@@ -596,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 = "g572b993";
+export const wakeVersion = "g950074e";

package/package.json

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