@atolis-hq/wake 0.2.29 → 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

@@ -44,13 +44,9 @@ export function createStaleRunReconciler(deps) {
             }
             return 'startup-recovery';
         }
-        const active = await deps.isRunningRecordActive(record);
+        const active = await deps.isRunningRecordActive(record, now);
         if (active) {
-            const startedAtMs = Date.parse(record.startedAt);
-            if (!Number.isFinite(startedAtMs)) {
-                return 'timeout';
-            }
-            return now.getTime() - startedAtMs >= deps.runnerTimeoutMs() ? 'timeout' : null;
+            return null;
         }
         if (record.lifecycle === 'RUNNING' || record.lifecycle === 'PROCESS_STARTING') {
             return 'runner-lock-not-active';

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,
@@ -450,6 +457,9 @@ export function createTickRunner(deps) {
                 status: 'running',
                 startedAt: nowIso,
                 routing,
+                lease,
+                workerPid: workerIdentity.pid,
+                workerProcessStartedAt: workerIdentity.processStartedAt,
             };
             await deps.stateStore.writeRunRecord(runningRecord);
             async function transitionRunLifecycle(lifecycle) {
@@ -491,6 +501,18 @@ 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'
@@ -521,6 +543,7 @@ export function createTickRunner(deps) {
                 });
                 const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
                 await transitionRunLifecycle('RUNNING');
+                startLeaseRenewal();
                 const runnerResult = await deps.runner.run({
                     action,
                     projection: candidate,
@@ -532,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.
@@ -709,6 +746,7 @@ 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;

package/dist/src/domain/schema.js

@@ -301,6 +301,13 @@ const runTokenUsageSchema = z.object({
     costUsd: z.number().nonnegative().optional(),
     turns: z.number().nonnegative().optional(),
 });
+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;
@@ -346,6 +353,11 @@ export const runRecordSchema = z.preprocess((input) => {
     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(),
 }));

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 = "gf58d7a3";
+export const wakeVersion = "gfb459ce";

package/package.json

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