@atolis-hq/wake 0.2.52 → 0.2.53

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;
@@ -1269,6 +1278,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 +1410,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 +1571,7 @@ export function createTickRunner(deps) {
                     ...(runnerResult.tokenUsage === undefined ? {} : { tokenUsage: runnerResult.tokenUsage }),
                     metadata: {
                         ...finalisingRecord.metadata,
+                        ...(workspaceBookkeeping === undefined ? {} : { workspaceBookkeeping }),
                         ...resultMetadata,
                     },
                 });
@@ -1680,6 +1709,9 @@ export function createTickRunner(deps) {
                     projection: candidate,
                     record: failedRecord,
                     failureClass: 'infra',
+                    ...(isWorkspaceValidationFailure(err)
+                        ? { failurePhase: 'workspace-validation' }
+                        : {}),
                     ...(failedRecordWorkspacePath === undefined
                         ? {}
                         : { workspacePath: failedRecordWorkspacePath }),
@@ -1696,6 +1728,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',

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 = "g6c20d18";

package/package.json

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