@atolis-hq/wake 0.2.28 → 0.2.30

package/dist/src/adapters/claude/claude-runner.js

@@ -218,6 +218,7 @@ export function createClaudeRunner(options) {
                 args,
                 cwd: input.workspacePath ?? options.cwd,
                 timeoutMs: options.settings.timeoutMs,
+                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
             });
             const responseTranscriptPath = await writeRunnerTranscript({
                 config: input.config,

package/dist/src/adapters/codex/codex-runner.js

@@ -261,6 +261,7 @@ export function createCodexRunner(options) {
                 }),
                 cwd,
                 timeoutMs: options.settings.timeoutMs,
+                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
             });
             const responseTranscriptPath = await writeRunnerTranscript({
                 config: input.config,

package/dist/src/adapters/cursor/cursor-runner.js

@@ -212,6 +212,7 @@ export function createCursorRunner(options) {
                 }),
                 cwd,
                 timeoutMs: options.settings.timeoutMs,
+                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
             });
             const responseTranscriptPath = await writeRunnerTranscript({
                 config: input.config,

package/dist/src/adapters/fs/state-store.js

@@ -172,6 +172,13 @@ export function createStateStore({ wakeRoot }) {
             await writeJsonFile(paths.runDateFile(parsed.startedAt.slice(0, 10), parsed.runId), parsed);
             return parsed;
         },
+        async updateRunRecordIf(runId, input) {
+            const current = await this.readRunRecord(runId);
+            if (current === null || !input.expect(current)) {
+                return null;
+            }
+            return this.writeRunRecord(input.update(current));
+        },
         async writeSourceState(record) {
             const parsed = parseSourceStateRecord(record);
             await writeJsonFile(paths.sourceStateFile(parsed.source, parsed.key), parsed);

package/dist/src/adapters/runner/cli-command.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { readProcessIdentity } from '../../lib/process-identity.js';
 const TIMEOUT_KILL_GRACE_MS = 5_000;
 export function runAgentCliCommand(input) {
     return new Promise((resolve, reject) => {
@@ -11,6 +12,16 @@ export function runAgentCliCommand(input) {
         let stderr = '';
         let timedOut = false;
         let killTimer;
+        let startNotification = Promise.resolve();
+        let startNotificationError;
+        if (input.onProcessStart !== undefined && child.pid !== undefined) {
+            const identity = readProcessIdentity(child.pid);
+            if (identity !== null) {
+                startNotification = input.onProcessStart(identity).catch((error) => {
+                    startNotificationError = error;
+                });
+            }
+        }
         const timeoutTimer = input.timeoutMs === undefined
             ? undefined
             : setTimeout(() => {
@@ -29,9 +40,14 @@ export function runAgentCliCommand(input) {
             clearTimeout(killTimer);
             reject(error);
         });
-        child.on('close', (exitCode) => {
+        child.on('close', async (exitCode) => {
             clearTimeout(timeoutTimer);
             clearTimeout(killTimer);
+            await startNotification;
+            if (startNotificationError !== undefined) {
+                reject(startNotificationError);
+                return;
+            }
             resolve({
                 stdout,
                 stderr,

package/dist/src/core/active-run-recovery.js

@@ -1,5 +1,6 @@
-import { readFileLockStatus } from '../lib/lock.js';
 import { maxConfiguredRunnerTimeoutMs } from '../domain/runner-routing.js';
+import { isRunLeaseExpired } from './run-lease.js';
+import { processIdentityMatches } from '../lib/process-identity.js';
 import { createOutbox } from './outbox.js';
 import { createProjectionUpdater } from './projection-updater.js';
 import { createStaleRunReconciler } from './stale-run-reconciler.js';
@@ -14,14 +15,18 @@ export function createActiveRunRecovery(deps) {
         stateStore: deps.stateStore,
         projectionUpdater,
     });
-    async function isRunningRecordActive(record) {
-        const lock = await readFileLockStatus(deps.stateStore.paths.runnerLockFile, {
-            expectedCommandIncludes: process.argv[1] === undefined ? [] : [process.argv[1]],
-        });
-        if (!lock.active || lock.metadata === undefined) {
-            return false;
+    async function isRunningRecordActive(record, now) {
+        if (record.lease !== undefined && !isRunLeaseExpired(record, now)) {
+            return true;
         }
-        return Date.parse(lock.metadata.acquiredAt) <= Date.parse(record.startedAt);
+        return (processIdentityMatches({
+            pid: record.agentPid,
+            processStartedAt: record.agentProcessStartedAt,
+        }) ||
+            processIdentityMatches({
+                pid: record.workerPid,
+                processStartedAt: record.workerProcessStartedAt,
+            }));
     }
     const { reconcileStaleRunningRecords } = createStaleRunReconciler({
         config: deps.config,

package/dist/src/core/run-lease.js

@@ -0,0 +1,38 @@
+import { randomUUID } from 'node:crypto';
+export const runLeaseDurationMs = 60_000;
+export const runLeaseRenewalIntervalMs = 20_000;
+export function createRunLease(input) {
+    const acquiredAt = input.clock.now();
+    const expiresAt = new Date(acquiredAt.getTime() + runLeaseDurationMs);
+    return {
+        leaseId: `lease-${randomUUID()}`,
+        ownerInstanceId: input.ownerInstanceId,
+        acquiredAt: acquiredAt.toISOString(),
+        lastRenewedAt: acquiredAt.toISOString(),
+        expiresAt: expiresAt.toISOString(),
+    };
+}
+export function isRunLeaseExpired(record, now) {
+    if (record.lease === undefined) {
+        return true;
+    }
+    return Date.parse(record.lease.expiresAt) <= now.getTime();
+}
+export async function renewRunLease(input) {
+    const now = input.clock.now();
+    const renewed = await input.stateStore.updateRunRecordIf(input.runId, {
+        expect: (record) => record.status === 'running' &&
+            record.lifecycle !== 'TERMINAL' &&
+            record.lease?.leaseId === input.leaseId &&
+            record.lease.ownerInstanceId === input.ownerInstanceId,
+        update: (record) => ({
+            ...record,
+            lease: {
+                ...record.lease,
+                lastRenewedAt: now.toISOString(),
+                expiresAt: new Date(now.getTime() + runLeaseDurationMs).toISOString(),
+            },
+        }),
+    });
+    return renewed !== null;
+}

package/dist/src/core/stale-run-reconciler.js

@@ -8,22 +8,107 @@ import { createEventEnvelope } from '../lib/event-log.js';
 // `deliverOutboundEvent` is injected rather than imported so this module does
 // not depend on the outbox module directly.
 export function createStaleRunReconciler(deps) {
+    function isTerminalLifecycle(lifecycle) {
+        return lifecycle === 'TERMINAL';
+    }
+    function recoveryOutcomeForLifecycle(lifecycle) {
+        switch (lifecycle) {
+            case 'CREATED':
+            case 'CLAIMED':
+            case 'PREPARING':
+                return 'CANCELED_BY_RECONCILIATION';
+            case 'PROCESS_STARTING':
+            case 'RUNNING':
+            case 'FINALISING':
+                return 'STALLED';
+            case 'TERMINAL':
+                return 'SUPERSEDED';
+        }
+    }
     async function staleReason(record, now) {
         if (record.status !== 'running') {
             return null;
         }
-        if (deps.isRunningRecordActive !== undefined && !(await deps.isRunningRecordActive(record))) {
+        if (isTerminalLifecycle(record.lifecycle)) {
+            return null;
+        }
+        if (deps.isRunningRecordActive === undefined) {
+            if (record.lifecycle !== 'CREATED' &&
+                record.lifecycle !== 'CLAIMED' &&
+                record.lifecycle !== 'PREPARING') {
+                const startedAtMs = Date.parse(record.startedAt);
+                if (!Number.isFinite(startedAtMs)) {
+                    return 'timeout';
+                }
+                return now.getTime() - startedAtMs >= deps.runnerTimeoutMs() ? 'timeout' : null;
+            }
+            return 'startup-recovery';
+        }
+        const active = await deps.isRunningRecordActive(record, now);
+        if (active) {
+            return null;
+        }
+        if (record.lifecycle === 'RUNNING' || record.lifecycle === 'PROCESS_STARTING') {
             return 'runner-lock-not-active';
         }
-        const startedAtMs = Date.parse(record.startedAt);
-        if (!Number.isFinite(startedAtMs)) {
-            return 'timeout';
+        return 'startup-recovery';
+    }
+    async function deliverRecoveredLabels(projection, runId, finishedAt) {
+        await deps.deliverOutboundEvent(createLabelsEvent({
+            projection,
+            runId,
+            statusLabel: 'wake:status.failed',
+            stageLabel: stageLabelForStage(projection.wake.stage),
+            workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(projection, deps.config)),
+            occurredAt: finishedAt,
+        }));
+    }
+    async function recoverMissingRunRecordClaims(runRecords, finishedAt) {
+        const knownRunIds = new Set(runRecords.map((record) => record.runId));
+        const projections = await deps.stateStore.listIssueStates();
+        for (const projection of projections) {
+            const runId = projection.wake.lastRunId;
+            if (runId === undefined ||
+                knownRunIds.has(runId) ||
+                runRecords.some((record) => record.workItemKey === projection.workItemKey) ||
+                projection.context.lastRunSentinel !== undefined) {
+                continue;
+            }
+            const event = createEventEnvelope({
+                eventId: `${runId}-missing-run-record-recovered`,
+                workItemKey: projection.workItemKey,
+                streamScope: 'work-item',
+                direction: 'internal',
+                sourceSystem: 'wake',
+                sourceEventType: 'wake.run.completed',
+                sourceRefs: {
+                    repo: projection.issue.repo,
+                    issueNumber: projection.issue.number,
+                    runId,
+                },
+                occurredAt: finishedAt,
+                ingestedAt: finishedAt,
+                trigger: 'immediate',
+                payload: {
+                    action: projection.context.lastRunAction,
+                    sentinel: 'FAILED',
+                    executionOutcome: 'CANCELED_BY_RECONCILIATION',
+                    runId,
+                    reason: 'runner:missing-run-record',
+                },
+            });
+            await deps.stateStore.appendEventEnvelope(event);
+            await deps.projectionUpdater.rebuildFromEvents([event]);
+            const updatedProjection = await deps.stateStore.readIssueState(projection.workItemKey);
+            if (updatedProjection !== null) {
+                await deliverRecoveredLabels(updatedProjection, runId, finishedAt);
+            }
         }
-        return now.getTime() - startedAtMs >= deps.runnerTimeoutMs() ? 'timeout' : null;
     }
     async function reconcileStaleRunningRecords(now) {
         const finishedAt = now.toISOString();
         const runRecords = await deps.stateStore.listRunRecords();
+        await recoverMissingRunRecordClaims(runRecords, finishedAt);
         const staleRecords = [];
         for (const record of runRecords) {
             const reason = await staleReason(record, now);
@@ -46,6 +131,7 @@ export function createStaleRunReconciler(deps) {
             if (projection === null || projection.wake.lastRunId !== record.runId || newerCompletedRun) {
                 await deps.stateStore.writeRunRecord({
                     ...record,
+                    lifecycle: 'TERMINAL',
                     status: 'superseded',
                     finishedAt,
                     executionOutcome: 'SUPERSEDED',
@@ -58,9 +144,10 @@ export function createStaleRunReconciler(deps) {
                 });
                 continue;
             }
-            const staleExecutionOutcome = reason === 'timeout' ? 'TIMED_OUT' : 'STALLED';
+            const staleExecutionOutcome = reason === 'timeout' ? 'TIMED_OUT' : recoveryOutcomeForLifecycle(record.lifecycle);
             await deps.stateStore.writeRunRecord({
                 ...record,
+                lifecycle: 'TERMINAL',
                 status: 'failed',
                 finishedAt,
                 sentinel: 'FAILED',
@@ -69,6 +156,7 @@ export function createStaleRunReconciler(deps) {
                 metadata: {
                     ...record.metadata,
                     reconciledBy: 'stale-running-record',
+                    recoveryLifecycle: record.lifecycle,
                     staleReason: reason,
                     timeoutMs: deps.runnerTimeoutMs(),
                 },
@@ -93,7 +181,11 @@ export function createStaleRunReconciler(deps) {
                     sentinel: 'FAILED',
                     executionOutcome: staleExecutionOutcome,
                     runId: record.runId,
-                    reason: reason === 'timeout' ? 'runner:stale-timeout' : 'runner:orphaned-process',
+                    reason: reason === 'timeout'
+                        ? 'runner:stale-timeout'
+                        : reason === 'startup-recovery'
+                            ? `runner:recover-${record.lifecycle.toLowerCase()}`
+                            : 'runner:orphaned-process',
                     ...(record.routing === undefined ? {} : { routing: record.routing }),
                 },
             });
@@ -101,14 +193,7 @@ export function createStaleRunReconciler(deps) {
             await deps.projectionUpdater.rebuildFromEvents([runCompletedEvent]);
             const updatedProjection = await deps.stateStore.readIssueState(projection.workItemKey);
             if (updatedProjection !== null) {
-                await deps.deliverOutboundEvent(createLabelsEvent({
-                    projection: updatedProjection,
-                    runId: record.runId,
-                    statusLabel: 'wake:status.failed',
-                    stageLabel: stageLabelForStage(updatedProjection.wake.stage),
-                    workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(updatedProjection, deps.config)),
-                    occurredAt: finishedAt,
-                }));
+                await deliverRecoveredLabels(updatedProjection, record.runId, finishedAt);
             }
         }
     }

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

@@ -1,7 +1,7 @@
 import { createLifecycleService } from './lifecycle-service.js';
 import { createPolicyEngine } from './policy-engine.js';
 import { createProjectionUpdater } from './projection-updater.js';
-import { acquireFileLock, readFileLockStatus } from '../lib/lock.js';
+import { acquireFileLock } from '../lib/lock.js';
 import { CORRELATION_REGISTERED_EVENT, parseRunnerArtifacts, parseRunnerResult, } from '../domain/schema.js';
 import { maxConfiguredRunnerTimeoutMs, resolveRunnerRouting } from '../domain/runner-routing.js';
 import { awaitingApprovalRunnerSentinel, stageLabelForStage } from '../domain/stages.js';
@@ -15,6 +15,8 @@ import { createOutbox } from './outbox.js';
 import { createEventResolver } from './event-resolver.js';
 import { createStaleRunReconciler } from './stale-run-reconciler.js';
 import { createWorkspaceCleanup } from './workspace-cleanup.js';
+import { createRunLease, isRunLeaseExpired, renewRunLease, runLeaseRenewalIntervalMs, } from './run-lease.js';
+import { currentProcessIdentity, processIdentityMatches } from '../lib/process-identity.js';
 function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
@@ -68,6 +70,7 @@ export function createTickRunner(deps) {
         workspaceManager: deps.workspaceManager,
         projectionUpdater,
     });
+    const ownerInstanceId = `instance-${process.pid}-${Date.now()}`;
     function isAwaitingApproval(projection) {
         return projection.context.lastRunSentinel === awaitingApprovalRunnerSentinel;
     }
@@ -204,14 +207,18 @@ export function createTickRunner(deps) {
     function runnerTimeoutMs() {
         return maxConfiguredRunnerTimeoutMs(deps.config);
     }
-    async function isRunningRecordActive(record) {
-        const lock = await readFileLockStatus(deps.stateStore.paths.runnerLockFile, {
-            expectedCommandIncludes: process.argv[1] === undefined ? [] : [process.argv[1]],
-        });
-        if (!lock.active || lock.metadata === undefined) {
-            return false;
+    async function isRunningRecordActive(record, now) {
+        if (record.lease !== undefined && !isRunLeaseExpired(record, now)) {
+            return true;
         }
-        return Date.parse(lock.metadata.acquiredAt) <= Date.parse(record.startedAt);
+        return (processIdentityMatches({
+            pid: record.agentPid,
+            processStartedAt: record.agentProcessStartedAt,
+        }) ||
+            processIdentityMatches({
+                pid: record.workerPid,
+                processStartedAt: record.workerProcessStartedAt,
+            }));
     }
     async function parkConfigDriftedProjections(projections) {
         let parked = false;
@@ -289,9 +296,7 @@ export function createTickRunner(deps) {
         }
     }
     async function runRunnerTick() {
-        const lock = await acquireFileLock(deps.stateStore.paths.runnerLockFile, {
-            staleAfterMs: runnerTimeoutMs(),
-        });
+        const lock = await acquireFileLock(deps.stateStore.paths.runnerLockFile);
         if (!lock.acquired) {
             return { status: 'locked' };
         }
@@ -439,6 +444,8 @@ export function createTickRunner(deps) {
                 return { status: 'idle' };
             }
             const runId = `run-${candidate.issue.number}-${deps.clock.now().getTime()}`;
+            const lease = createRunLease({ clock: deps.clock, ownerInstanceId });
+            const workerIdentity = currentProcessIdentity();
             const runningRecord = {
                 schemaVersion: 1,
                 runId,
@@ -446,10 +453,21 @@ export function createTickRunner(deps) {
                 repo: candidate.issue.repo,
                 issueNumber: candidate.issue.number,
                 action,
+                lifecycle: 'CREATED',
                 status: 'running',
                 startedAt: nowIso,
+                routing,
+                lease,
+                workerPid: workerIdentity.pid,
+                workerProcessStartedAt: workerIdentity.processStartedAt,
             };
             await deps.stateStore.writeRunRecord(runningRecord);
+            async function transitionRunLifecycle(lifecycle) {
+                await deps.stateStore.writeRunRecord({
+                    ...(await deps.stateStore.readRunRecord(runId)),
+                    lifecycle,
+                });
+            }
             const claimedAt = eventStampNow();
             const claimedEvent = createEventEnvelope({
                 eventId: `${runId}-claimed`,
@@ -473,6 +491,7 @@ export function createTickRunner(deps) {
                 },
             });
             await deps.stateStore.appendEventEnvelope(claimedEvent);
+            await transitionRunLifecycle('CLAIMED');
             await projectionUpdater.rebuildFromEvents([claimedEvent]);
             await deliverOutboundEvent(createLabelsEvent({
                 projection: candidate,
@@ -482,7 +501,20 @@ export function createTickRunner(deps) {
                 workflowLabel: workflowLabelForWorkflowName(workflowName),
                 occurredAt: eventStampNow(),
             }));
+            let leaseRenewalTimer;
+            function startLeaseRenewal() {
+                leaseRenewalTimer = setInterval(() => {
+                    void renewRunLease({
+                        stateStore: deps.stateStore,
+                        runId,
+                        leaseId: lease.leaseId,
+                        ownerInstanceId,
+                        clock: deps.clock,
+                    });
+                }, runLeaseRenewalIntervalMs);
+            }
             try {
+                await transitionRunLifecycle('PREPARING');
                 const prepareResult = workspaceMode === 'branch'
                     ? await deps.workspaceManager.prepareWorkspace({
                         workId: candidate.workItemKey,
@@ -499,7 +531,19 @@ export function createTickRunner(deps) {
                 const upstreamChanges = 'upstreamChanges' in prepareResult && typeof prepareResult.upstreamChanges === 'string'
                     ? prepareResult.upstreamChanges
                     : undefined;
+                const preparedRecord = (await deps.stateStore.readRunRecord(runId));
+                await deps.stateStore.writeRunRecord({
+                    ...preparedRecord,
+                    lifecycle: 'PROCESS_STARTING',
+                    metadata: {
+                        ...preparedRecord.metadata,
+                        ...(workspacePath === undefined ? {} : { workspacePath }),
+                        workspaceMode,
+                    },
+                });
                 const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
+                await transitionRunLifecycle('RUNNING');
+                startLeaseRenewal();
                 const runnerResult = await deps.runner.run({
                     action,
                     projection: candidate,
@@ -511,7 +555,21 @@ export function createTickRunner(deps) {
                     ...(workspacePath === undefined ? {} : { workspacePath }),
                     ...(mergeConflictDetected ? { mergeConflictDetected: true } : {}),
                     ...(upstreamChanges === undefined ? {} : { upstreamChanges }),
+                    onProcessStart: async (identity) => {
+                        await deps.stateStore.updateRunRecordIf(runId, {
+                            expect: (record) => record.status === 'running' &&
+                                record.lease?.leaseId === lease.leaseId &&
+                                record.lease.ownerInstanceId === ownerInstanceId,
+                            update: (record) => ({
+                                ...record,
+                                agentPid: identity.pid,
+                                agentProcessStartedAt: identity.processStartedAt,
+                            }),
+                        });
+                    },
                 });
+                clearInterval(leaseRenewalTimer);
+                leaseRenewalTimer = undefined;
                 const parsedRunnerResult = parseRunnerResult(runnerResult.result);
                 const rawSentinel = parsedRunnerResult.status;
                 // Coerce DONE → AWAITING_APPROVAL when the stage requires human sign-off.
@@ -583,8 +641,11 @@ export function createTickRunner(deps) {
                         : sentinel === 'AWAITING_APPROVAL'
                             ? 'AWAITING_APPROVAL'
                             : undefined;
+                await transitionRunLifecycle('FINALISING');
+                const finalisingRecord = (await deps.stateStore.readRunRecord(runId));
                 await deps.stateStore.writeRunRecord({
-                    ...runningRecord,
+                    ...finalisingRecord,
+                    lifecycle: 'TERMINAL',
                     status: sentinel === 'DONE'
                         ? 'completed'
                         : sentinel === 'BLOCKED'
@@ -600,7 +661,10 @@ export function createTickRunner(deps) {
                     summary: parsedRunnerResult.body,
                     ...(runnerResult.routing === undefined ? {} : { routing: runnerResult.routing }),
                     ...(runnerResult.tokenUsage === undefined ? {} : { tokenUsage: runnerResult.tokenUsage }),
-                    metadata: resultMetadata,
+                    metadata: {
+                        ...finalisingRecord.metadata,
+                        ...resultMetadata,
+                    },
                 });
                 const runCompletedEvent = createEventEnvelope({
                     eventId: `${runId}-completed`,
@@ -682,10 +746,13 @@ export function createTickRunner(deps) {
                 };
             }
             catch (err) {
+                clearInterval(leaseRenewalTimer);
                 const finishedAt = deps.clock.now().toISOString();
                 const sentinel = 'FAILED';
+                const failedRecord = (await deps.stateStore.readRunRecord(runId)) ?? runningRecord;
                 await deps.stateStore.writeRunRecord({
-                    ...runningRecord,
+                    ...failedRecord,
+                    lifecycle: 'TERMINAL',
                     status: 'failed',
                     finishedAt,
                     sentinel,

package/dist/src/domain/schema.js

@@ -34,8 +34,18 @@ export const workflowOutcomeValues = [
     'AWAITING_INPUT',
     'CHANGES_REQUESTED',
 ];
+export const executionAttemptLifecycleValues = [
+    'CREATED',
+    'CLAIMED',
+    'PREPARING',
+    'PROCESS_STARTING',
+    'RUNNING',
+    'FINALISING',
+    'TERMINAL',
+];
 export const executionOutcomeSchema = z.enum(executionOutcomeValues);
 export const workflowOutcomeSchema = z.enum(workflowOutcomeValues);
+export const executionAttemptLifecycleSchema = z.enum(executionAttemptLifecycleValues);
 export const defaultAgentIdentity = 'Wake';
 export const defaultSmokePrompt = `This is ${defaultAgentIdentity}, reply with "hi ${defaultAgentIdentity} only"`;
 const modelOverridesSchema = z
@@ -291,7 +301,27 @@ const runTokenUsageSchema = z.object({
     costUsd: z.number().nonnegative().optional(),
     turns: z.number().nonnegative().optional(),
 });
-export const runRecordSchema = z.object({
+const runLeaseSchema = z.object({
+    leaseId: z.string(),
+    ownerInstanceId: z.string(),
+    acquiredAt: isoTimestampSchema,
+    lastRenewedAt: isoTimestampSchema,
+    expiresAt: isoTimestampSchema,
+});
+function legacyRunLifecycle(input) {
+    if (input.lifecycle !== undefined) {
+        return input;
+    }
+    return {
+        ...input,
+        lifecycle: input.status === 'running' ? 'RUNNING' : 'TERMINAL',
+    };
+}
+export const runRecordSchema = z.preprocess((input) => {
+    return input !== null && typeof input === 'object'
+        ? legacyRunLifecycle(input)
+        : input;
+}, z.object({
     schemaVersion: z.literal(1),
     runId: z.string(),
     // The work item this run belongs to. Required: run records are Wake-owned
@@ -306,7 +336,15 @@ export const runRecordSchema = z.object({
     repo: z.string(),
     issueNumber: z.number().int().positive(),
     action: identifierSchema,
-    status: z.enum(['running', 'completed', 'awaiting-approval', 'blocked', 'failed', 'superseded']),
+    lifecycle: executionAttemptLifecycleSchema,
+    status: z.enum([
+        'running',
+        'completed',
+        'awaiting-approval',
+        'blocked',
+        'failed',
+        'superseded',
+    ]),
     startedAt: isoTimestampSchema,
     finishedAt: isoTimestampSchema.optional(),
     sessionId: z.string().optional(),
@@ -315,9 +353,14 @@ export const runRecordSchema = z.object({
     workflowOutcome: workflowOutcomeSchema.optional(),
     summary: z.string().optional(),
     routing: runnerRoutingSchema.optional(),
+    lease: runLeaseSchema.optional(),
+    workerPid: z.number().int().positive().optional(),
+    workerProcessStartedAt: z.string().optional(),
+    agentPid: z.number().int().positive().optional(),
+    agentProcessStartedAt: z.string().optional(),
     tokenUsage: runTokenUsageSchema.optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
-});
+}));
 const runnerHealthEntrySchema = z.object({
     pausedUntil: isoTimestampSchema.optional(),
     // 'reported' = CLI told us the real reset time; 'estimated' = exponential

package/dist/src/lib/lock.js

@@ -156,11 +156,11 @@ export async function acquireFileLock(path, options) {
     }
     catch (error) {
         if (error.code === 'EEXIST') {
-            if (options?.staleAfterMs !== undefined &&
-                !(await readFileLockStatus(path, {
-                    staleAfterMs: options.staleAfterMs,
-                    now: options.now ?? new Date(),
-                })).active) {
+            const status = await readFileLockStatus(path, {
+                ...(options?.staleAfterMs === undefined ? {} : { staleAfterMs: options.staleAfterMs }),
+                now: options?.now ?? new Date(),
+            });
+            if (!status.active) {
                 await rm(path, { force: true });
                 try {
                     return await tryAcquire();

package/dist/src/lib/process-identity.js

@@ -0,0 +1,54 @@
+import { readFileSync } from 'node:fs';
+const currentProcessStartedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
+function readLinuxProcessStartTicks(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const endCommand = stat.lastIndexOf(')');
+        if (endCommand === -1) {
+            return undefined;
+        }
+        const fields = stat
+            .slice(endCommand + 2)
+            .trim()
+            .split(/\s+/);
+        const startTicks = fields[19];
+        return startTicks === undefined ? undefined : `linux-start-ticks:${startTicks}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readProcessIdentity(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return null;
+    }
+    try {
+        process.kill(pid, 0);
+    }
+    catch (error) {
+        if (error.code === 'ESRCH') {
+            return null;
+        }
+    }
+    const linuxStartedAt = readLinuxProcessStartTicks(pid);
+    if (linuxStartedAt !== undefined) {
+        return { pid, processStartedAt: linuxStartedAt };
+    }
+    if (pid === process.pid) {
+        return { pid, processStartedAt: currentProcessStartedAt };
+    }
+    return null;
+}
+export function currentProcessIdentity() {
+    return (readProcessIdentity(process.pid) ?? {
+        pid: process.pid,
+        processStartedAt: currentProcessStartedAt,
+    });
+}
+export function processIdentityMatches(input) {
+    if (input.pid === undefined || input.processStartedAt === undefined) {
+        return false;
+    }
+    const current = readProcessIdentity(input.pid);
+    return current?.processStartedAt === input.processStartedAt;
+}

package/dist/src/version.js

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

package/package.json

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