@atolis-hq/wake 0.3.53 → 0.3.55

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "gfcfd038";
+export const wakeVersion = "g4d17da0";

package/dist/src/control-plane/application/advance-once.js

@@ -1,4 +1,4 @@
-import { RunStatus, WorkspaceMode } from '../../execution/index.js';
+import { ActivationClaimConflictError, RunStatus, WorkspaceMode } from '../../execution/index.js';
 import { correlationId, EventActorKind, } from '../../kernel/index.js';
 import { WorkflowStatus } from '../../orchestration/index.js';
 import { WorkStatus } from '../../work/index.js';
@@ -141,15 +141,23 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
         const correlated = await resources.correlationsForWork(selected.workflow.workItemId);
         const resourceViews = (await Promise.all(correlated.map((entry) => resources.get(entry.resourceId)))).filter((resource) => resource !== null);
         const ineligible = await runnerIneligibility();
-        const run = await execution.attempt(selected.activation, {
-            workItemId: selected.workflow.workItemId,
-            workflowInstanceId: selected.workflow.workflowInstanceId,
-            orchestrationGroupId: selected.workflow.orchestrationGroupId,
-            resources: resourceViews,
-            sessionPolicy: selected.workflow.parentWorkflowInstanceId === undefined ? 'resume-stage' : 'fresh',
-            awaitImmediateCompletion: true,
-            ...(ineligible.size === 0 ? {} : { ineligibleRunners: ineligible }),
-        });
+        let run;
+        try {
+            run = await execution.attempt(selected.activation, {
+                workItemId: selected.workflow.workItemId,
+                workflowInstanceId: selected.workflow.workflowInstanceId,
+                orchestrationGroupId: selected.workflow.orchestrationGroupId,
+                resources: resourceViews,
+                sessionPolicy: selected.workflow.parentWorkflowInstanceId === undefined ? 'resume-stage' : 'fresh',
+                awaitImmediateCompletion: true,
+                ...(ineligible.size === 0 ? {} : { ineligibleRunners: ineligible }),
+            });
+        }
+        catch (error) {
+            if (error instanceof ActivationClaimConflictError)
+                return { kind: 'no-work' };
+            throw error;
+        }
         if (run.status === RunStatus.Succeeded && run.outcome !== undefined) {
             if (await isDispatchPaused())
                 return { kind: 'paused' };

package/dist/src/execution/application/activation-claim.js

@@ -2,13 +2,19 @@ import { EventActorKind, EventSourceKind, } from '../../kernel/index.js';
 import { createActivationExecutionEventDraft } from '../contracts/event-factory.js';
 import { decodeActivationExecutionEvent, ExecutionEventType, } from '../contracts/events.js';
 import { activationStream } from '../contracts/streams.js';
+export class ActivationClaimConflictError extends Error {
+    constructor(activationId) {
+        super(`Activation ${activationId} already has an active Run claim`);
+        this.name = 'ActivationClaimConflictError';
+    }
+}
 export async function claimActivation(input) {
     const { journal, clock, config, activationId, runId, owner, occurredAt } = input;
     const stream = activationStream(activationId);
     const events = (await journal.readStream(stream)).map(decodeActivationExecutionEvent);
     const last = events.at(-1);
     if (last?.eventType === ExecutionEventType.ActivationClaimed && claimIsUnexpired(last, clock))
-        throw new Error(`Activation ${activationId} already has an active Run claim`);
+        throw new ActivationClaimConflictError(activationId);
     await journal.append(stream, events.length, [
         createActivationExecutionEventDraft({
             eventId: `${activationId}:claim:${runId}`,

package/dist/src/execution/index.js

@@ -1,5 +1,6 @@
 export * from './application/execution-projection.js';
 export * from './application/execution-service.js';
+export * from './application/activation-claim.js';
 export * from './application/recovery-service.js';
 export * from './application/run-repository.js';
 export * from './contracts/commands.js';

package/dist/src/persistence/filesystem/file-lock.js

@@ -5,10 +5,12 @@ const maximumOwnerRecords = 1024;
 const compatibilityAcquiredAt = '9999-12-31T23:59:59.999Z';
 export async function acquireFileLock(path, options) {
     await mkdir(dirname(path), { recursive: true });
+    const identity = await processIdentity(process.pid, options);
     const metadata = {
         pid: process.pid,
         acquiredAt: (options?.now ?? new Date()).toISOString(),
         lockId: randomUUID(),
+        ...(identity === null ? {} : { processIdentity: identity }),
     };
     return options?.staleRequiresDeadProcess
         ? acquireStrictFileLock(path, metadata, options)
@@ -226,10 +228,17 @@ async function ownerBlocksAcquisition(path, options) {
         return true;
     return ownerMetadataBlocks(owner, options);
 }
-function ownerMetadataBlocks(owner, options) {
+async function ownerMetadataBlocks(owner, options) {
     if (options?.staleAfterMs === undefined || !isStale(owner, options))
         return true;
-    return Boolean(options.staleRequiresDeadProcess && ownerMayBeAlive(options, owner.pid));
+    if (!options.staleRequiresDeadProcess || !ownerMayBeAlive(options, owner.pid))
+        return false;
+    const identity = await processIdentity(owner.pid, options);
+    if (owner.processIdentity !== undefined)
+        return identity === null || identity === owner.processIdentity;
+    const startedAt = await processStartedAt(owner.pid, options);
+    return (startedAt === null ||
+        startedAt.getTime() <= Date.parse(owner.acquiredAt) + processStartToleranceMilliseconds);
 }
 function ownerRecordName(metadata) {
     return `${metadata.pid}-${Date.parse(metadata.acquiredAt)}-${metadata.lockId}.json`;
@@ -257,6 +266,57 @@ function ownerMayBeAlive(options, pid) {
         return true;
     }
 }
+const processStartToleranceMilliseconds = 1_000;
+async function processIdentity(pid, options) {
+    if (options?.processIdentity !== undefined)
+        return options.processIdentity(pid);
+    if (process.platform !== 'linux')
+        return null;
+    try {
+        return `linux-start-ticks:${await linuxProcessStartTicks(pid)}`;
+    }
+    catch {
+        return null;
+    }
+}
+async function processStartedAt(pid, options) {
+    if (options.processStartedAt !== undefined)
+        return options.processStartedAt(pid);
+    if (process.platform !== 'linux')
+        return null;
+    try {
+        const [targetTicks, selfTicks, procStat] = await Promise.all([
+            linuxProcessStartTicks(pid),
+            linuxProcessStartTicks(process.pid),
+            readFile('/proc/stat', 'utf8'),
+        ]);
+        const bootSeconds = /^btime (\d+)$/m.exec(procStat)?.[1];
+        if (bootSeconds === undefined)
+            return null;
+        const currentProcessStartedAt = Date.now() - process.uptime() * 1_000;
+        const elapsedSinceBootMilliseconds = currentProcessStartedAt - Number(bootSeconds) * 1_000;
+        if (elapsedSinceBootMilliseconds <= 0)
+            return null;
+        const ticksPerMillisecond = selfTicks / elapsedSinceBootMilliseconds;
+        if (!Number.isFinite(ticksPerMillisecond) || ticksPerMillisecond <= 0)
+            return null;
+        return new Date(Number(bootSeconds) * 1_000 + targetTicks / ticksPerMillisecond);
+    }
+    catch {
+        return null;
+    }
+}
+async function linuxProcessStartTicks(pid) {
+    const raw = await readFile(`/proc/${pid}/stat`, 'utf8');
+    const fields = raw
+        .slice(raw.lastIndexOf(')') + 2)
+        .trim()
+        .split(/\s+/);
+    const startTicks = Number(fields[19]);
+    if (!Number.isSafeInteger(startTicks) || startTicks < 0)
+        throw new Error('Invalid process start ticks');
+    return startTicks;
+}
 export async function withFileLock(path, operation) {
     const lock = await acquireFileLock(path, {
         staleAfterMs: 60_000,

package/package.json

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