@atolis-hq/wake 0.3.54 → 0.3.56

package/dist/src/bootstrap/surface-api-work-applications.js

@@ -1,7 +1,7 @@
 import { pullRequestProjection } from '../activities/index.js';
 import { executionProjection, runsByWorkflowInstanceProjection, } from '../execution/index.js';
 import { correlationId, EventActorKind } from '../kernel/index.js';
-import { isOperatorRetryEligible, OperatorRetryIneligibleError, orchestrationProjection, workflowsByWorkItemProjection, } from '../orchestration/index.js';
+import { OperatorRetryIneligibleError, orchestrationProjection, selectOperatorRetryTarget, workflowsByWorkItemProjection, } from '../orchestration/index.js';
 import { workCorrelationsProjection, } from '../resources/index.js';
 import { ApiCommandStatus, fromWorkItemKey, presentResource, presentRun, presentWorkflowInstance, presentWorkItem, } from '../surfaces/index.js';
 import { workItemId, WorkStatus } from '../work/index.js';
@@ -70,13 +70,14 @@ export function createSurfaceWorkApplications(root, now) {
                 return retryIneligible('Work item is deleted');
             if (work.state !== WorkStatus.Open)
                 return retryIneligible('Work item is not open');
-            const primary = (await root.orchestration.listAll()).find((value) => value.workItemId === id && value.parentWorkflowInstanceId === undefined);
-            if (primary === undefined)
+            const workflows = (await root.orchestration.listAll()).filter((workflow) => workflow.workItemId === id);
+            if (!workflows.some((workflow) => workflow.parentWorkflowInstanceId === undefined))
                 return retryIneligible('Work item has no primary workflow');
-            if (!isOperatorRetryEligible(primary))
+            const target = selectOperatorRetryTarget(workflows);
+            if (target === undefined)
                 return retryIneligible('Workflow is not retry eligible');
             try {
-                await root.orchestration.retryBlockedFailedStage(primary.workflowInstanceId, commandContext(command.idempotencyKey, now));
+                await root.orchestration.retryBlockedFailedStage(target.workflowInstanceId, commandContext(command.idempotencyKey, now));
             }
             catch (error) {
                 if (error instanceof OperatorRetryIneligibleError)

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 = "gb23a2a1";
+export const wakeVersion = "ga125b02";

package/dist/src/integrations/github/application/inbound-review-signals.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 import { ActivityOutcomeKind, ReviewActorKind, ReviewDecisionKind, ReviewerAuthorizationSource, createPullRequestService, isReviewAuthorized, } from '../../../activities/index.js';
-import { ApprovalAuthorityKind } from '../../../orchestration/index.js';
+import { ApprovalAuthorityKind, selectOperatorRetryTarget, } from '../../../orchestration/index.js';
 import { BuiltInResourceKind, ResourceCorrelationRole, ResourceStreamKind, resourceId, } from '../../../resources/index.js';
 import { WorkStatus } from '../../../work/index.js';
 import { UnknownGitHubIdentity } from '../contracts/vocabulary.js';
@@ -128,13 +128,14 @@ async function applyIssueRetrySignal(input) {
     const workItemIds = (await resources.correlations(resourceIdValue))
         .filter((correlation) => correlation.role === ResourceCorrelationRole.Primary)
         .map((correlation) => correlation.workItemId);
-    for (const workflow of await orchestration.listAll()) {
-        if (!workItemIds.includes(workflow.workItemId) ||
-            workflow.parentWorkflowInstanceId !== undefined)
+    const workflows = await orchestration.listAll();
+    for (const workItemId of workItemIds) {
+        if (!(await isEligibleWorkItem(work, workItemId)))
             continue;
-        if (!(await isEligibleWorkItem(work, workflow.workItemId)))
+        const target = selectOperatorRetryTarget(workflows.filter((workflow) => workflow.workItemId === workItemId));
+        if (target === undefined)
             continue;
-        await ignoreIneligibleOperatorRetry(() => orchestration.retryBlockedFailedStage(workflow.workflowInstanceId, commandContext(event)));
+        await ignoreIneligibleOperatorRetry(() => orchestration.retryBlockedFailedStage(target.workflowInstanceId, commandContext(event)));
     }
 }
 async function applyIssueApprovalSignal(input) {

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

@@ -10,7 +10,7 @@ import { finishRoute } from './transition.js';
 export { startInstance } from './activation-policy.js';
 export { acceptSignal, waitForSignal } from './signal-policy.js';
 export { requestSupplementalActivity } from './supplemental-policy.js';
-export { isChangesResumeEligible, isOperatorRetryEligible, requestChangesResume, requestOperatorRetry, } from './operator-retry-policy.js';
+export { isChangesResumeEligible, isOperatorRetryEligible, requestChangesResume, requestOperatorRetry, selectOperatorRetryTarget, } from './operator-retry-policy.js';
 export function acceptActivityOutcome(definition, state, input) {
     if (!isPendingOutcome(state, input))
         return { kind: 'ignored', reason: 'outcome is not for the pending activation' };

package/dist/src/orchestration/domain/operator-retry-policy.js

@@ -1,7 +1,7 @@
 import { ActivityOutcomeKind, BuiltInActivityName } from '../../activities/index.js';
-import { OrchestrationEventType } from '../contracts/events.js';
-import { stageName } from '../contracts/identifiers.js';
-import { ActivityActivationStatus, WorkflowStatus } from '../contracts/vocabulary.js';
+import { OrchestrationEventType, WatchGateVerdictSignal } from '../contracts/events.js';
+import { stageName, watchId } from '../contracts/identifiers.js';
+import { ActivityActivationStatus, ApprovalAuthorityKind, WorkflowStatus, } from '../contracts/vocabulary.js';
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
 export function isOperatorRetryEligible(view) {
     const pending = view.pendingActivation;
@@ -17,6 +17,23 @@ export function isOperatorRetryEligible(view) {
         view.lastOutcome?.kind === ActivityOutcomeKind.Failed) ||
         view.executionFailure?.activationId === pending.activationId);
 }
+export function selectOperatorRetryTarget(workflows) {
+    const primary = workflows.find((workflow) => workflow.parentWorkflowInstanceId === undefined);
+    if (primary === undefined)
+        return undefined;
+    if (isOperatorRetryEligible(primary))
+        return primary;
+    if (primary.status !== WorkflowStatus.Waiting ||
+        primary.waitingFor?.signalKind !== WatchGateVerdictSignal)
+        return undefined;
+    const watched = new Set((primary.waitingFor.from ?? []).flatMap((authority) => authority.kind === ApprovalAuthorityKind.Watch ? [authority.watch] : []));
+    return workflows.find((workflow) => workflow.parentWorkflowInstanceId === primary.workflowInstanceId &&
+        workflow.workItemId === primary.workItemId &&
+        workflow.orchestrationGroupId === primary.orchestrationGroupId &&
+        workflow.watchId !== undefined &&
+        watched.has(watchId(workflow.watchId)) &&
+        isOperatorRetryEligible(workflow));
+}
 export function isChangesResumeEligible(view) {
     const pending = view.pendingActivation;
     return (view.status === WorkflowStatus.Blocked &&

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.54",
+  "version": "0.3.56",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {