@atolis-hq/wake 0.2.51 → 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/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,63 @@ 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.metadata?.failureSource === 'wake-workspace-validation') {
+        return 'workspace-validation';
+    }
+    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 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;
+    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();
@@ -1221,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);
@@ -1350,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
@@ -1464,6 +1540,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,11 +1565,13 @@ 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 }),
                     metadata: {
                         ...finalisingRecord.metadata,
+                        ...(workspaceBookkeeping === undefined ? {} : { workspaceBookkeeping }),
                         ...resultMetadata,
                     },
                 });
@@ -1519,6 +1607,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 +1701,21 @@ 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',
+                    ...(isWorkspaceValidationFailure(err)
+                        ? { failurePhase: 'workspace-validation' }
+                        : {}),
+                    ...(failedRecordWorkspacePath === undefined
+                        ? {}
+                        : { workspacePath: failedRecordWorkspacePath }),
+                });
                 await deps.stateStore.writeRunRecord({
                     ...failedRecord,
                     lifecycle: 'TERMINAL',
@@ -1619,10 +1723,15 @@ export function createTickRunner(deps) {
                     finishedAt,
                     sentinel,
                     executionOutcome: 'PROCESS_FAILED',
+                    ...failureContext,
                     summary: err instanceof Error ? err.message : String(err),
                     metadata: {
                         ...failedRecord.metadata,
                         failureClass: 'infra',
+                        ...(isWorkspaceValidationFailure(err)
+                            ? { failureSource: 'wake-workspace-validation' }
+                            : {}),
+                        ...failureContext,
                     },
                 });
                 const runCompletedEvent = createEventEnvelope({
@@ -1646,6 +1755,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,23 @@ const runLeaseSchema = z.object({
     lastRenewedAt: isoTimestampSchema,
     expiresAt: isoTimestampSchema,
 });
+export const failurePhaseSchema = z.enum([
+    'workspace-validation',
+    '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 +386,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 = "g6c20d18";

package/package.json

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