@atolis-hq/wake 0.3.18 → 0.3.20

package/dist/src/orchestration/domain/transition.js

@@ -1,17 +1,26 @@
-import { OrchestrationEventType, WatchGateVerdictSignal } from '../contracts/events.js';
+import { OrchestrationEventType, ResourceTransitionSignal, WatchGateVerdictSignal, } from '../contracts/events.js';
 import { ApprovalAuthorityKind, TransitionTargetKind } from '../contracts/vocabulary.js';
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+// Route completion combines the mutually exclusive wait, await, and target policies.
+// eslint-disable-next-line complexity
 export function finishRoute(events, definition, state, input, route) {
-    if (route.watchGates !== undefined) {
-        const gate = route.watchGates[0];
+    if (route.watchGates !== undefined || route.resourceTransitions !== undefined) {
+        const gate = route.watchGates?.[0];
         events.push(stateDraft(state, input, OrchestrationEventType.SignalWaitStarted, {
-            signalKind: WatchGateVerdictSignal,
-            from: Object.freeze([
-                { kind: ApprovalAuthorityKind.Watch, watch: gate.watch },
-                { kind: ApprovalAuthorityKind.Human },
-            ]),
+            signalKind: gate === undefined ? ResourceTransitionSignal : WatchGateVerdictSignal,
+            ...(gate === undefined
+                ? {}
+                : {
+                    from: Object.freeze([
+                        { kind: ApprovalAuthorityKind.Watch, watch: gate.watch },
+                        { kind: ApprovalAuthorityKind.Human },
+                    ]),
+                }),
             resume: route.target,
-            onRejectResume: gate.onRejectTarget,
+            ...(gate === undefined ? {} : { onRejectResume: gate.onRejectTarget }),
+            ...(route.resourceTransitions === undefined
+                ? {}
+                : { resourceTransitions: route.resourceTransitions }),
         }, events.length + 1));
         return;
     }

package/dist/src/orchestration/domain/workflow-graph.js

@@ -1,7 +1,11 @@
 import { stageName } from '../contracts/identifiers.js';
 import { TransitionTargetKind } from '../contracts/vocabulary.js';
 function edges(stages, name) {
-    return Object.values(stages[name].on).flatMap((route) => route.target.kind === TransitionTargetKind.Stage ? [route.target.stage] : []);
+    return Object.values(stages[name].on).flatMap((route) => [
+        route.target,
+        ...(route.watchGates ?? []).map((gate) => gate.onRejectTarget),
+        ...(route.resourceTransitions ?? []).map((transition) => transition.target),
+    ].flatMap((target) => (target.kind === TransitionTargetKind.Stage ? [target.stage] : [])));
 }
 export function assertReachable(entry, stages) {
     const reached = new Set();

package/dist/src/orchestration/domain/workflow-instance-events.js

@@ -178,6 +178,9 @@ function applySignalWaitStarted(state, event) {
         ...(event.payload.onRejectResume === undefined
             ? {}
             : { onRejectResume: event.payload.onRejectResume }),
+        ...(event.payload.resourceTransitions === undefined
+            ? {}
+            : { resourceTransitions: event.payload.resourceTransitions }),
     };
 }
 function updateActivationStatus(state, activationId, status) {

package/dist/src/orchestration/index.js

@@ -2,6 +2,10 @@ export * from './application/orchestration-projection.js';
 export * from './application/orchestration-repository.js';
 export * from './application/orchestration-service.js';
 export * from './application/advance-workflow.js';
+export * from './application/pull-request-transition-evidence.js';
+export * from './application/resource-transition-evidence.js';
+export * from './application/resource-transition-matching.js';
+export * from './application/resource-transition-reactor.js';
 export * from './application/signal-reactor.js';
 export * from './application/watch-reactor.js';
 export * from './application/workflow-definition-registry.js';

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

@@ -1,6 +1,8 @@
 import { randomUUID } from 'node:crypto';
-import { mkdir, open, readFile, rm } from 'node:fs/promises';
-import { dirname } from 'node:path';
+import { mkdir, open, readdir, readFile, rm, rmdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+const maximumOwnerRecords = 1024;
+const compatibilityAcquiredAt = '9999-12-31T23:59:59.999Z';
 export async function acquireFileLock(path, options) {
     await mkdir(dirname(path), { recursive: true });
     const metadata = {
@@ -8,51 +10,219 @@ export async function acquireFileLock(path, options) {
         acquiredAt: (options?.now ?? new Date()).toISOString(),
         lockId: randomUUID(),
     };
+    return options?.staleRequiresDeadProcess
+        ? acquireStrictFileLock(path, metadata, options)
+        : acquireLegacyFileLock(path, metadata, options);
+}
+async function acquireStrictFileLock(path, metadata, options) {
+    const ownersPath = `${path}.owners`;
+    await mkdir(ownersPath, { recursive: true });
+    const legacy = await inspectLegacyOwner(path, ownersPath, options);
+    if (legacy.blocks)
+        return unavailableFileLock();
+    if (legacy.reclaimableProtectedOwnerRecord !== undefined)
+        await rm(join(ownersPath, legacy.reclaimableProtectedOwnerRecord), { force: true });
+    const ownerName = ownerRecordName(metadata);
+    const ownerPath = join(ownersPath, ownerName);
+    await createOwnerRecord(ownerPath, metadata);
     try {
-        return await createFileLock(path, metadata);
+        const candidates = await readdir(ownersPath);
+        if (candidates.length > maximumOwnerRecords) {
+            await rm(ownerPath, { force: true });
+            return unavailableFileLock();
+        }
+        if (await hasBlockingOwner(candidates, ownersPath, ownerName, legacy, options)) {
+            await rm(ownerPath, { force: true });
+            return unavailableFileLock();
+        }
+        const ownsCompatibilityPath = await createCompatibilityOwner(path, metadata, ownerName);
+        if (!ownsCompatibilityPath && (await inspectLegacyOwner(path, ownersPath, options)).blocks) {
+            await rm(ownerPath, { force: true });
+            return unavailableFileLock();
+        }
+        return {
+            acquired: true,
+            metadata,
+            async release() {
+                let peers;
+                try {
+                    peers = (await readdir(ownersPath)).filter((candidate) => candidate !== ownerName);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        return;
+                    throw error;
+                }
+                if (peers.length === 0)
+                    await releaseCompatibilityOwner(path);
+                await rm(ownerPath, { force: true });
+                await removeEmptyOwnerDirectory(ownersPath);
+            },
+        };
     }
     catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-        return reclaimStaleFileLock(path, metadata, options);
+        await rm(ownerPath, { force: true });
+        throw error;
     }
 }
-async function createFileLock(path, metadata) {
-    const handle = await open(path, 'wx');
+async function removeEmptyOwnerDirectory(path) {
     try {
-        await handle.writeFile(`${JSON.stringify(metadata)}\n`, 'utf8');
-        await handle.sync();
+        await rmdir(path);
     }
-    finally {
-        await handle.close();
+    catch {
+        // A concurrent owner may have populated the directory.
     }
-    return { acquired: true, metadata, release: () => releaseFileLock(path, metadata) };
 }
-async function releaseFileLock(path, metadata) {
+async function acquireLegacyFileLock(path, metadata, options) {
     try {
-        const current = JSON.parse(await readFile(path, 'utf8'));
-        if (current.lockId === metadata.lockId)
-            await rm(path, { force: true });
+        return await createLegacyFileLock(path, metadata);
     }
-    catch {
-        /* already released */
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
     }
-}
-async function reclaimStaleFileLock(path, metadata, options) {
     if (options?.staleAfterMs === undefined)
         return unavailableFileLock();
     try {
         const prior = JSON.parse(await readFile(path, 'utf8'));
         if (!isStale(prior, options))
             return unavailableFileLock();
-        if (options.staleRequiresDeadProcess && ownerMayBeAlive(options, prior.pid))
-            return unavailableFileLock();
     }
     catch {
-        // A corrupt or vanished lock has no trustworthy owner and can be reclaimed.
+        // Preserve the historical time-only recovery contract for malformed or vanished locks.
     }
     await rm(path, { force: true });
-    return createFileLock(path, metadata);
+    try {
+        return await createLegacyFileLock(path, metadata);
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            return unavailableFileLock();
+        throw error;
+    }
+}
+async function createLegacyFileLock(path, metadata) {
+    await createOwnerRecord(path, metadata);
+    return {
+        acquired: true,
+        metadata,
+        release: () => releaseLegacyFileLock(path, metadata.lockId),
+    };
+}
+async function releaseLegacyFileLock(path, lockId) {
+    try {
+        const current = JSON.parse(await readFile(path, 'utf8'));
+        if (current.lockId === lockId)
+            await rm(path, { force: true });
+    }
+    catch {
+        /* already released */
+    }
+}
+async function hasBlockingOwner(candidates, ownersPath, ownerName, legacy, options) {
+    for (const candidate of candidates) {
+        if (candidate === ownerName || candidate === legacy.protectedOwnerRecord)
+            continue;
+        const candidatePath = join(ownersPath, candidate);
+        if (await ownerBlocksAcquisition(candidatePath, options))
+            return true;
+        if (options?.staleRequiresDeadProcess)
+            await rm(candidatePath, { force: true });
+    }
+    return false;
+}
+async function inspectLegacyOwner(path, ownersPath, options) {
+    let legacy;
+    try {
+        legacy = JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        return { blocks: error.code !== 'ENOENT' };
+    }
+    if (!('compatibilityOwner' in legacy)) {
+        return { blocks: true };
+    }
+    const ownerPath = join(ownersPath, legacy.ownerRecord);
+    const blocks = await ownerBlocksAcquisition(ownerPath, options);
+    return {
+        blocks,
+        protectedOwnerRecord: legacy.ownerRecord,
+        ...(blocks ? {} : { reclaimableProtectedOwnerRecord: legacy.ownerRecord }),
+    };
+}
+async function createCompatibilityOwner(path, metadata, ownerRecord) {
+    try {
+        await createOwnerRecord(path, {
+            ...metadata,
+            acquiredAt: compatibilityAcquiredAt,
+            compatibilityOwner: true,
+            ownerRecord,
+        });
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            return false;
+        throw error;
+    }
+}
+async function releaseCompatibilityOwner(path) {
+    try {
+        const owner = JSON.parse(await readFile(path, 'utf8'));
+        if (owner.compatibilityOwner)
+            await rm(path, { force: true });
+    }
+    catch {
+        /* already released */
+    }
+}
+async function createOwnerRecord(path, metadata) {
+    let handle;
+    try {
+        handle = await open(path, 'wx');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        await mkdir(dirname(path), { recursive: true });
+        handle = await open(path, 'wx');
+    }
+    try {
+        await handle.writeFile(`${JSON.stringify(metadata)}\n`, 'utf8');
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function ownerBlocksAcquisition(path, options) {
+    let owner;
+    try {
+        owner = JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        const encoded = /^(\d+)-(\d+)-([^.]+)\.json$/.exec(path.split(/[\\/]/).at(-1) ?? '');
+        if (encoded === null)
+            return true;
+        owner = {
+            pid: Number(encoded[1]),
+            acquiredAt: new Date(Number(encoded[2])).toISOString(),
+            lockId: encoded[3],
+        };
+    }
+    if (options?.staleAfterMs === undefined || !isStale(owner, options))
+        return true;
+    return ownerMetadataBlocks(owner, options);
+}
+function ownerMetadataBlocks(owner, options) {
+    if (options?.staleAfterMs === undefined || !isStale(owner, options))
+        return true;
+    return Boolean(options.staleRequiresDeadProcess && ownerMayBeAlive(options, owner.pid));
+}
+function ownerRecordName(metadata) {
+    return `${metadata.pid}-${Date.parse(metadata.acquiredAt)}-${metadata.lockId}.json`;
 }
 function isStale(prior, options) {
     return ((options.now ?? new Date()).getTime() - Date.parse(prior.acquiredAt) >= options.staleAfterMs);
@@ -74,12 +244,14 @@ function ownerMayBeAlive(options, pid) {
         return (options.isProcessAlive ?? isProcessAlive)(pid);
     }
     catch {
-        // Permission and platform-probe failures are indeterminate: never steal a live owner's lock.
         return true;
     }
 }
 export async function withFileLock(path, operation) {
-    const lock = await acquireFileLock(path, { staleAfterMs: 60_000 });
+    const lock = await acquireFileLock(path, {
+        staleAfterMs: 60_000,
+        staleRequiresDeadProcess: true,
+    });
     if (!lock.acquired)
         throw new Error(`File lock is already held: ${path}`);
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {
@@ -34,11 +34,12 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/embed-version.mjs && node scripts/check-cli-entrypoint.mjs",
     "prepack": "npm run build && npm run build:web",
-    "test": "vitest run",
+    "test": "npm run test:unit",
     "test:fast": "npm run test:unit",
     "check:catalogue": "node scripts/check-functional-catalogue.mjs",
     "check:scenarios": "node scripts/check-scenario-coverage.mjs",
     "check:specs": "node scripts/check-specs.mjs",
+    "check:specs:report": "node scripts/report-spec-drift.mjs",
     "lint:architecture": "node scripts/check-module-manifests.mjs && node scripts/check-contract-vocabulary.mjs && depcruise --config dependency-cruiser.config.mjs src",
     "build:docker": "tsc -p tsconfig.docker.json && node scripts/embed-version.mjs && npm run build:web",
     "build:web": "npm --workspace @atolis-hq/wake-web run build",
@@ -62,7 +63,8 @@
     "smoke:claude": "tsx src/main.ts smoke claude",
     "smoke:codex": "tsx src/main.ts smoke codex",
     "smoke:cursor": "tsx src/main.ts smoke cursor",
-    "verify": "npm run check:catalogue && npm run check:scenarios && npm run lint:architecture && npm run lint && npm run format:check && npm run build && npm test"
+    "verify": "npm run check:catalogue && npm run check:scenarios && npm run check:specs:report && npm run lint:architecture && npm run lint && npm run format:check && npm run build && npm run test:unit",
+    "verify:ci": "npm run verify && npm run test:architecture && npm run test:integration && npm run test:e2e && npm run knip && npm run test:web"
   },
   "dependencies": {
     "@octokit/rest": "^22.0.0",