@atolis-hq/wake 0.4.42 → 0.4.44

package/dist/src/bootstrap/config/root-schema.d.ts

@@ -69,6 +69,7 @@ declare const orchestrationConfigSchema: z.ZodDefault<z.ZodObject<{
                         kind: z.ZodLiteral<"watch">;
                         id: z.ZodString;
                     }, z.core.$strict>]>>>;
+                    timeoutMs: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
                 watchGates: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     watch: z.ZodString;
@@ -215,6 +216,7 @@ export declare const rootConfigSchema: z.ZodObject<{
                             kind: z.ZodLiteral<"watch">;
                             id: z.ZodString;
                         }, z.core.$strict>]>>>;
+                        timeoutMs: z.ZodOptional<z.ZodNumber>;
                     }, z.core.$strict>>;
                     watchGates: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                         watch: z.ZodString;

package/dist/src/bootstrap/self-update-application.d.ts

@@ -16,6 +16,7 @@ export interface SourceUpdatePort {
  * non-sandbox self-updates.
  */
 export interface SelfUpdateRolloutPort {
+    prepare(tag: string): Promise<void>;
     deploy(tag: string): Promise<void>;
     rollback(tag: string): Promise<void>;
     recordFailure(tag: string, error: unknown): Promise<void>;
@@ -27,6 +28,7 @@ export interface SelfUpdateRolloutPort {
  * durably record every supplied Run's maintenance request.
  */
 export interface SelfUpdateQuiescePort {
+    read?(): Promise<UpdateMaintenanceState | null>;
     acquire(tag: string, retryFailed?: boolean): Promise<UpdateMaintenanceState>;
     exclusive?<Value>(tag: string, retryFailed: boolean, operation: (state: UpdateMaintenanceState) => Promise<Value>): Promise<Value>;
     activeRuns(): Promise<readonly {

package/dist/src/bootstrap/self-update-application.js

@@ -59,6 +59,11 @@ async function currentTag(input) {
     return (await input.source.currentTag?.()) ?? (await input.ledger.read());
 }
 async function startUpdateAttempt(input, tag, force) {
+    const existing = await input.quiesce?.read?.();
+    if (existing === null ||
+        existing === undefined ||
+        existing.phase === UpdateMaintenancePhase.Failed)
+        await prepareCandidate(input, tag);
     if (input.quiesce?.exclusive !== undefined)
         return input.quiesce.exclusive(tag, force, (lease) => updateAttempt(input, tag, force, lease));
     return updateAttempt(input, tag, force, await input.quiesce?.acquire(tag, force));
@@ -66,24 +71,30 @@ async function startUpdateAttempt(input, tag, force) {
 async function updateAttempt(input, tag, force, lease) {
     const maintenanceTag = lease?.tag ?? tag;
     const attemptId = lease?.attemptId;
-    const context = {};
+    const context = {
+        activationStarted: false,
+        rollbackSucceeded: false,
+        recoveryRequired: false,
+        recoveryVerified: false,
+    };
     try {
         return await performUpdateAttempt(input, tag, force, lease, context);
     }
     catch (error) {
-        await recordUpdateFailure(input, maintenanceTag, attemptId, context.deployError ?? error, error);
+        await recordUpdateFailure(input, maintenanceTag, attemptId, context.deployError ?? error, error, context);
         throw error;
     }
 }
 async function performUpdateAttempt(input, tag, force, lease, context) {
     if (lease !== undefined && requiresMaintenanceRecovery(lease)) {
+        context.recoveryRequired = true;
         await resumePendingMaintenance(input, lease);
         return false;
     }
     if (!isStartableMaintenanceLease(lease, tag))
         return false;
     await quiesceForUpdate(input);
-    await recoverPendingUpdate(input.ledger, input.source);
+    await recoverPendingUpdate(input.ledger, input.source, context);
     if (!force && (await input.ledger.read()) === tag) {
         await input.quiesce?.clear(lease?.attemptId);
         return false;
@@ -116,13 +127,18 @@ async function runForwardUpdate(input, tag, attemptId, context) {
             readLedger: input.ledger.read,
             writeLedger: input.ledger.write,
             update: async (nextTag) => {
-                await input.source.checkout(nextTag);
+                if (input.rollout === undefined)
+                    await input.source.checkout(nextTag);
+                context.activationStarted = true;
                 context.deployError = await deployRollout(input.rollout, nextTag);
             },
             health: async () => context.deployError === undefined && input.source.healthy(),
             rollback: async (priorTag) => {
                 await rollbackUpdate(input, priorTag, attemptId);
+                if (!(await input.source.healthy()))
+                    throw new Error(`Self-update rollback could not verify the prior tag ${priorTag}`);
                 rollbackSucceeded = true;
+                context.rollbackSucceeded = true;
             },
         });
     }
@@ -162,7 +178,18 @@ async function rollbackUpdate(input, priorTag, attemptId) {
     await input.source.checkout(priorTag);
     await input.rollout?.rollback(priorTag);
 }
-async function recordUpdateFailure(input, tag, attemptId, rolloutError, originalError) {
+async function recordUpdateFailure(input, tag, attemptId, rolloutError, originalError, context) {
+    if (context.rollbackSucceeded ||
+        (!context.activationStarted && (!context.recoveryRequired || context.recoveryVerified))) {
+        try {
+            await recordRolloutFailure(input.rollout, tag, rolloutError);
+            await input.ledger.recordBad(tag);
+        }
+        finally {
+            await input.quiesce?.clear(attemptId);
+        }
+        return;
+    }
     try {
         await input.quiesce?.fail(originalError, attemptId);
     }
@@ -184,6 +211,24 @@ async function recordRolloutFailure(rollout, tag, error) {
         // Best-effort: a failure-log write must never mask the original update failure.
     }
 }
+async function prepareCandidate(input, tag) {
+    if (!(await input.source.isClean()))
+        throw new Error('Self-update requires a clean source checkout');
+    if (input.rollout === undefined)
+        return;
+    const priorTag = await input.ledger.read();
+    try {
+        await input.source.checkout(tag);
+        await input.rollout.prepare(tag);
+    }
+    catch (error) {
+        if (priorTag !== null)
+            await input.source.checkout(priorTag);
+        await recordRolloutFailure(input.rollout, tag, error);
+        await input.ledger.recordBad(tag);
+        throw new UpdateCandidateFailure(error);
+    }
+}
 /**
  * A restart must never repeat a forward deploy. The persisted phase tells us
  * that source/rollout work may already have begun, so recover the prior
@@ -210,11 +255,13 @@ async function quiesceActiveRuns(quiesce) {
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }
-async function recoverPendingUpdate(ledger, source) {
+async function recoverPendingUpdate(ledger, source, context) {
     const priorTag = await ledger.recover();
     if (priorTag === null)
         return;
+    context.recoveryRequired = true;
     await source.checkout(priorTag);
     if (!(await source.healthy()))
         throw new Error(`Self-update recovery could not verify the prior tag ${priorTag}`);
+    context.recoveryVerified = true;
 }

package/dist/src/bootstrap/surface-cli-applications.js

@@ -400,6 +400,7 @@ async function activeExecutionRunIds(root) {
 /** The production maintenance boundary shared by the CLI update application. */
 export function createSelfUpdateQuiescePort(root) {
     return {
+        read: () => root.maintenance.read(),
         acquire: (tag, retryFailed) => root.maintenance.acquire(tag, retryFailed),
         exclusive: (tag, retryFailed, operation) => root.maintenance.runExclusive(tag, retryFailed, operation),
         activeRuns: () => activeExecutionRuns(root),
@@ -433,18 +434,20 @@ function createSandboxRuntimeApplications(root) {
     };
 }
 /**
- * Builds a running self-update on the sandbox container onto a specific
- * image tag: rebuild the image, swap the container onto it, and confirm the
- * resident `wake start` process actually came back up. Reused for both the
- * forward deploy and a same-shaped rollback to a previously-built tag.
+ * Builds a candidate image before the maintenance window. A failed build
+ * cannot affect the running sandbox.
  */
-async function deploySandboxTag(root, docker, tag, image, overrides) {
+async function buildSandboxTag(root, docker, image, overrides) {
     const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image, ...overrides }));
-    const wakeInvocation = overrides?.development?.mode === 'source'
+    await port.build();
+}
+/** Swaps the already-built candidate image and verifies the resident host. */
+async function deploySandboxTag(root, docker, tag, image, development) {
+    const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image, development }));
+    const wakeInvocation = development?.mode === 'source'
         ? ['node', '/app/dist/src/main.js']
         : sandboxWakeInvocation(root);
     const healthcheckRoot = `/tmp/wake-self-update-healthcheck-${tag}`;
-    await port.build();
     try {
         await port.update();
     }
@@ -541,15 +544,14 @@ function createOperationalApplications(root) {
                 ledger: createUpdateLedger(root.paths.wakeRoot),
                 source: updatePort,
                 rollout: {
-                    async deploy(deployTag) {
-                        await waitForActiveRuns({
-                            activeRunIds: () => activeExecutionRunIds(root),
-                            sleep: async (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
-                        });
-                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`, {
+                    async prepare(prepareTag) {
+                        await buildSandboxTag(root, dockerCli, `${imageRepository}:${prepareTag}`, {
                             development: updateDevelopment,
-                            buildVersion: deployTag,
+                            buildVersion: prepareTag,
                         });
+                    },
+                    async deploy(deployTag) {
+                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`, updateDevelopment);
                         // A later deploy succeeding after a prior rollback clears the stale warning.
                         await failureLog.clear();
                     },

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.42";
+export const wakeVersion = "v0.4.44";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/control-plane/application/activation-scheduler-ports.d.ts

@@ -12,6 +12,7 @@ export interface OrchestrationPort {
         activation: ActivityActivationView;
     }[]>;
     listWaiting(): Promise<readonly (WorkflowInstanceView | null)[]>;
+    expireTimedOutWaits?(context: CommandContext): Promise<readonly WorkflowInstanceView[]>;
     listAll?(): Promise<readonly WorkflowInstanceView[]>;
     validateActivationDispatch?(workflowInstanceId: string, context: CommandContext): Promise<boolean>;
     acceptOutcome(command: {

package/dist/src/control-plane/application/activation-scheduler.js

@@ -1,7 +1,7 @@
 /* eslint-disable complexity, max-lines-per-function */
 import { correlationId, EventActorKind } from '@atolis-hq/eventing';
 import { RunStatus } from '../../execution/index.js';
-import { isAmbiguityResolutionBlock, WorkflowStatus } from '../../orchestration/index.js';
+import { isAmbiguityResolutionBlock, WorkflowStatus, } from '../../orchestration/index.js';
 import { WorkStatus } from '../../work/index.js';
 import { ControlStreamKind } from '../contracts/streams.js';
 import { DispatchPolicy } from '../domain/dispatch-policy.js';
@@ -83,6 +83,12 @@ export function createActivationScheduler(orchestration, execution, resources, c
             return { kind: 'exhausted', progressCount: 0 };
         if (await isDispatchPaused())
             return { kind: 'paused' };
+        let expired = [];
+        if (orchestration.expireTimedOutWaits !== undefined) {
+            expired = await orchestration.expireTimedOutWaits(context('await-timeout-expiry'));
+            if (await isDispatchPaused())
+                return { kind: 'paused' };
+        }
         const rawPending = await orchestration.listPendingActivations(options.workItemId);
         const pending = (await Promise.all(rawPending.map(async (candidate) => {
             const work = await dependencies.work?.get(candidate.workflow.workItemId);
@@ -138,7 +144,7 @@ export function createActivationScheduler(orchestration, execution, resources, c
                 reason: recovery.run.failure?.message ?? 'execution failed',
             };
         }
-        return runDispatchLoop(pending, {
+        const result = await runDispatchLoop(pending, {
             orchestration,
             execution,
             resources,
@@ -149,6 +155,15 @@ export function createActivationScheduler(orchestration, execution, resources, c
             isDispatchPaused,
             commandContext: context,
         });
+        if (expired.length === 0 ||
+            (result.kind !== 'no-work' && result.kind !== WorkflowStatus.Waiting))
+            return result;
+        const workflow = expired[0];
+        return {
+            kind: WorkflowStatus.Blocked,
+            workflowInstanceId: workflow.workflowInstanceId,
+            reason: workflow.blockReason ?? 'await.timeout-exceeded',
+        };
     };
     const serialise = dependencies.schedulerSerialiser ?? createInProcessSerialiser();
     return {

package/dist/src/orchestration/application/accept-signal.js

@@ -1,4 +1,4 @@
-import { acceptSignal as decideSignal, waitForSignal as decideSignalWait, } from '../domain/interpreter.js';
+import { acceptSignal as decideSignal, waitForSignal as decideSignalWait, expireTimedOutAwait, } from '../domain/interpreter.js';
 export class AcceptSignal {
     repository;
     workflows;
@@ -21,6 +21,14 @@ export class AcceptSignal {
     }
     async execute(workflowInstanceId, signal, context) {
         const loaded = await this.repository.loadRequired(workflowInstanceId);
+        const expiry = expireTimedOutAwait(loaded.view, {
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        if (expiry.kind === 'append') {
+            await this.repository.append(workflowInstanceId, loaded.sequence, expiry.events);
+            return (await this.repository.loadRequired(workflowInstanceId)).view;
+        }
         const item = await this.work.get(loaded.view.workItemId);
         const definition = await this.workflows.definitionForOperation(loaded.view, loaded.sequence, context);
         if (definition === null)

package/dist/src/orchestration/application/advance-workflow.d.ts

@@ -16,6 +16,7 @@ export declare class AdvanceWorkflow {
     requestSupplementalActivity(id: WorkflowInstanceId, request: SupplementalActivityRequest, context: CommandContext): Promise<import("../index.js").WorkflowInstanceView>;
     markActivationStarted(id: WorkflowInstanceId, activationId: ActivationId, context: CommandContext): Promise<import("../index.js").WorkflowInstanceView | null>;
     block(id: WorkflowInstanceId, reason: string, context: CommandContext): Promise<import("../index.js").WorkflowInstanceView | null>;
+    expireTimedOutWaits(context: CommandContext): Promise<import("../index.js").WorkflowInstanceView[]>;
     resolveExecutionFailure(id: WorkflowInstanceId, input: {
         readonly activationId: ActivationId;
         readonly runId: string;

package/dist/src/orchestration/application/advance-workflow.js

@@ -6,6 +6,7 @@ import { workflowEventData } from '../domain/decision-events.js';
 import { requestChangesResume as decideChangesResume, requestFreshOperatorRetry as decideFreshOperatorRetry, requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, isNeedsClarificationResumeEligible, requestRunnerQuotaRetry, } from '../domain/interpreter.js';
 import { isAuthorisedActor } from '../domain/supplemental-policy.js';
 import { appendWithIntentRecovery } from './durable-append.js';
+import { expireTimedOutWaits } from './expire-timed-out-waits.js';
 import { acceptResourceTransition, matchResourceTransitions, } from './resource-transition-matching.js';
 import { matchWatches } from './watch-matching.js';
 export class OperatorRetryIneligibleError extends Error {
@@ -75,6 +76,9 @@ export class AdvanceWorkflow {
         await this.repository.append(id, loaded.sequence, [event]);
         return (await this.repository.load(id)).view;
     }
+    async expireTimedOutWaits(context) {
+        return expireTimedOutWaits(this.repository, context);
+    }
     async resolveExecutionFailure(id, input, context) {
         const loaded = await this.repository.load(id);
         if (loaded.view === null ||

package/dist/src/orchestration/application/expire-timed-out-waits.d.ts

@@ -0,0 +1,3 @@
+import type { CommandContext } from '@atolis-hq/eventing';
+import type { OrchestrationRepository } from './orchestration-repository.js';
+export declare function expireTimedOutWaits(repository: OrchestrationRepository, context: CommandContext): Promise<import("../index.js").WorkflowInstanceView[]>;

package/dist/src/orchestration/application/expire-timed-out-waits.js

@@ -0,0 +1,17 @@
+import { expireTimedOutAwait } from '../domain/interpreter.js';
+export async function expireTimedOutWaits(repository, context) {
+    const expired = [];
+    for (const loaded of await repository.list()) {
+        if (loaded.view === null)
+            continue;
+        const decision = expireTimedOutAwait(loaded.view, {
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        if (decision.kind === 'ignored')
+            continue;
+        await repository.append(loaded.view.workflowInstanceId, loaded.sequence, decision.events);
+        expired.push((await repository.loadRequired(loaded.view.workflowInstanceId)).view);
+    }
+    return expired;
+}

package/dist/src/orchestration/application/orchestration-service.d.ts

@@ -72,6 +72,7 @@ export declare class OrchestrationService {
         activation: import("../contracts/views.js").ActivityActivationView;
     }[]>;
     listWaiting(signalKind?: SignalName): Promise<WorkflowInstanceView[]>;
+    expireTimedOutWaits(context: CommandContext): Promise<WorkflowInstanceView[]>;
     listAll(): Promise<WorkflowInstanceView[]>;
     listCurrentDefinitions(): readonly {
         readonly definition: CompiledWorkflow;

package/dist/src/orchestration/application/orchestration-service.js

@@ -177,6 +177,9 @@ export class OrchestrationService {
     listWaiting(signalKind) {
         return this.advanceWorkflow.listWaiting(signalKind);
     }
+    expireTimedOutWaits(context) {
+        return this.advanceWorkflow.expireTimedOutWaits(context);
+    }
     listAll() {
         return this.advanceWorkflow.listAll();
     }

package/dist/src/orchestration/contracts/config.d.ts

@@ -14,6 +14,7 @@ export declare const awaitConfigSchema: z.ZodObject<{
         kind: z.ZodLiteral<"watch">;
         id: z.ZodString;
     }, z.core.$strict>]>>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 declare const watchGateConfigSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     watch: z.ZodString;
@@ -86,6 +87,7 @@ export declare const outcomeRouteConfigSchema: z.ZodObject<{
             kind: z.ZodLiteral<"watch">;
             id: z.ZodString;
         }, z.core.$strict>]>>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     watchGates: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         watch: z.ZodString;
@@ -139,6 +141,7 @@ export declare const stageConfigSchema: z.ZodObject<{
                 kind: z.ZodLiteral<"watch">;
                 id: z.ZodString;
             }, z.core.$strict>]>>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         watchGates: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             watch: z.ZodString;
@@ -236,6 +239,7 @@ export declare const workflowDefinitionConfigSchema: z.ZodObject<{
                     kind: z.ZodLiteral<"watch">;
                     id: z.ZodString;
                 }, z.core.$strict>]>>>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
             watchGates: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 watch: z.ZodString;
@@ -308,6 +312,8 @@ export interface CompiledAwait {
     readonly signal: SignalName;
     readonly from: readonly ApprovalAuthority[];
     readonly resume: TransitionTarget;
+    /** Opt-in bound for this explicit await; omitted waits indefinitely. */
+    readonly timeoutMs?: number;
 }
 export interface CompiledWatchGate {
     readonly watch: WatchId;

package/dist/src/orchestration/contracts/config.js

@@ -20,6 +20,7 @@ export const awaitConfigSchema = z
     .object({
     signal: identifier,
     from: z.array(approvalAuthorityConfigSchema).min(1).readonly(),
+    timeoutMs: z.number().int().positive().optional(),
 })
     .strict();
 const watchGateConfigSchema = z.union([

package/dist/src/orchestration/contracts/event-decoder.d.ts

@@ -71,6 +71,8 @@ export declare const activityRequestedSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const expectationSchema: z.ZodObject<{
     signalKind: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").SignalName, string>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    waitStartedAt: z.ZodOptional<z.ZodString>;
     suppressWatchDispatch: z.ZodOptional<z.ZodLiteral<true>>;
     resourceId: z.ZodOptional<z.ZodString>;
     revision: z.ZodOptional<z.ZodString>;

package/dist/src/orchestration/contracts/event-decoder.js

@@ -121,6 +121,8 @@ const resourceTransitionSchema = z
 export const expectationSchema = z
     .object({
     signalKind: brandedStringSchema(signalName),
+    timeoutMs: z.number().int().positive().optional(),
+    waitStartedAt: z.string().datetime().optional(),
     suppressWatchDispatch: z.literal(true).optional(),
     resourceId: z.string().optional(),
     revision: z.string().optional(),

package/dist/src/orchestration/contracts/events.d.ts

@@ -187,6 +187,10 @@ export interface ActivityRequestedPayload {
 }
 export interface SignalExpectation {
     readonly signalKind: SignalName;
+    /** Present only for an explicit workflow await with a configured deadline. */
+    readonly timeoutMs?: number | undefined;
+    /** The control-plane time recorded by the durable wait-start event. */
+    readonly waitStartedAt?: string | undefined;
     /** Re-arm a blocked gate without treating its wait event as a new watch trigger. */
     readonly suppressWatchDispatch?: true | undefined;
     readonly resourceId?: string | undefined;

package/dist/src/orchestration/contracts/views.d.ts

@@ -17,6 +17,8 @@ export interface ActivityActivationView {
 }
 export interface SignalExpectationView {
     readonly signalKind: SignalName;
+    readonly timeoutMs?: number;
+    readonly waitStartedAt?: string;
     readonly suppressWatchDispatch?: true;
     readonly intentEventId?: string;
     readonly resourceId?: string;

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

@@ -159,6 +159,7 @@ function compileAwait(workflow, rawStageName, resume, config, declaredWatchIds)
         signal: signalName(config.signal),
         from: Object.freeze(config.from.map((entry) => compileAuthority(workflow, rawStageName, entry, declaredWatchIds))),
         resume,
+        ...(config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs }),
     });
 }
 function compileAuthority(workflow, rawStageName, entry, declaredWatchIds) {

package/dist/src/orchestration/domain/interpreter.d.ts

@@ -3,7 +3,7 @@ import type { WorkflowInstanceView } from '../contracts/views.js';
 import { type AcceptActivityOutcome, type OrchestrationDecision } from './activation-policy.js';
 export { startInstance } from './activation-policy.js';
 export type { AcceptActivityOutcome, DecisionContext, OrchestrationDecision, QueueSupplementalActivity, StartInstanceInput, } from './activation-policy.js';
-export { acceptSignal, waitForSignal } from './signal-policy.js';
+export { acceptSignal, AwaitTimeoutBlockReason, expireTimedOutAwait, hasTimedOutAwait, waitForSignal, } from './signal-policy.js';
 export type { AcceptSignal } from './signal-policy.js';
 export { requestSupplementalActivity } from './supplemental-policy.js';
 export type { SupplementalActivityRequest } from './supplemental-policy.js';

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

@@ -8,7 +8,7 @@ import { acceptWaitingOutcome } from './signal-policy.js';
 import { finishSupplemental, requestNextSupplemental } from './supplemental-policy.js';
 import { finishRoute } from './transition.js';
 export { startInstance } from './activation-policy.js';
-export { acceptSignal, waitForSignal } from './signal-policy.js';
+export { acceptSignal, AwaitTimeoutBlockReason, expireTimedOutAwait, hasTimedOutAwait, waitForSignal, } from './signal-policy.js';
 export { requestSupplementalActivity } from './supplemental-policy.js';
 export { isChangesResumeEligible, isGroupBudgetExtensionEligible, isNeedsClarificationResumeEligible, isOperatorRetryEligible, requestChangesResume, requestFreshOperatorRetry, requestOperatorRetry, selectOperatorRetryTarget, } from './operator-retry-policy.js';
 export { isRunnerQuotaRetryEligible, requestRunnerQuotaRetry, } from './runner-quota-retry-policy.js';

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

@@ -3,6 +3,7 @@ import { OrchestrationEventType, WatchGateVerdictSignal } from '../contracts/eve
 import { signalName, stageName, watchId } from '../contracts/identifiers.js';
 import { ActivityActivationStatus, ApprovalAuthorityKind, WorkflowStatus, } from '../contracts/vocabulary.js';
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+import { AwaitTimeoutBlockReason } from './signal-policy.js';
 // `then: await-human` on a `failed` route compiles its wait to this literal
 // signal name (see compileTarget); a workflow parked there has exhausted
 // whatever automatic retries it had and is durably equivalent to a blocked
@@ -22,8 +23,9 @@ export function isOperatorRetryEligible(view) {
     return isRetryEligibleFailedWait(view);
 }
 function isRetryEligibleBlock(view, pending) {
-    return ((view.blockReason === 'unconfigured outcome failed' &&
-        view.lastOutcome?.kind === ActivityOutcomeKind.Failed) ||
+    return (view.blockReason === AwaitTimeoutBlockReason ||
+        (view.blockReason === 'unconfigured outcome failed' &&
+            view.lastOutcome?.kind === ActivityOutcomeKind.Failed) ||
         view.executionFailure?.activationId === pending.activationId);
 }
 function isRetryEligibleFailedWait(view) {

package/dist/src/orchestration/domain/signal-policy.d.ts

@@ -2,10 +2,14 @@ import type { CompiledWorkflow } from '../contracts/config.js';
 import type { OrchestrationSignal, SignalExpectation } from '../contracts/events.js';
 import type { WorkflowInstanceView } from '../contracts/views.js';
 import type { AcceptActivityOutcome, DecisionContext, OrchestrationDecision } from './activation-policy.js';
+/** Stable reason used whenever an explicit workflow await reaches its deadline. */
+export declare const AwaitTimeoutBlockReason = "await.timeout-exceeded";
 export interface AcceptSignal extends DecisionContext {
     readonly signal: OrchestrationSignal;
     readonly consent?: boolean;
 }
 export declare function waitForSignal(state: WorkflowInstanceView, expectation: SignalExpectation, input: DecisionContext): OrchestrationDecision;
 export declare function acceptSignal(definition: CompiledWorkflow, state: WorkflowInstanceView, input: AcceptSignal): OrchestrationDecision;
+export declare function hasTimedOutAwait(state: WorkflowInstanceView, occurredAt: string): boolean;
+export declare function expireTimedOutAwait(state: WorkflowInstanceView, input: DecisionContext): OrchestrationDecision;
 export declare function acceptWaitingOutcome(state: WorkflowInstanceView, input: AcceptActivityOutcome): OrchestrationDecision;

package/dist/src/orchestration/domain/signal-policy.js

@@ -4,6 +4,8 @@ import { stageName } from '../contracts/identifiers.js';
 import { ActivityActivationStatus, ApprovalAuthorityKind, WorkflowStatus, } from '../contracts/vocabulary.js';
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
 import { resumeToTarget } from './transition.js';
+/** Stable reason used whenever an explicit workflow await reaches its deadline. */
+export const AwaitTimeoutBlockReason = 'await.timeout-exceeded';
 export function waitForSignal(state, expectation, input) {
     if (state.status !== WorkflowStatus.Waiting && state.status !== WorkflowStatus.Blocked)
         return { kind: 'ignored', reason: 'WorkflowInstance is not waiting or blocked' };
@@ -36,6 +38,29 @@ export function acceptSignal(definition, state, input) {
         requestLegacyReentry(events, definition, state, input);
     return { kind: 'append', events };
 }
+export function hasTimedOutAwait(state, occurredAt) {
+    const wait = state.waitingFor;
+    if (state.status !== WorkflowStatus.Waiting || wait?.timeoutMs === undefined)
+        return false;
+    if (wait.waitStartedAt === undefined)
+        return false;
+    const startedAt = Date.parse(wait.waitStartedAt);
+    const now = Date.parse(occurredAt);
+    return Number.isFinite(startedAt) && Number.isFinite(now) && now >= startedAt + wait.timeoutMs;
+}
+export function expireTimedOutAwait(state, input) {
+    if (!hasTimedOutAwait(state, input.occurredAt))
+        return { kind: 'ignored', reason: 'WorkflowInstance await has not timed out' };
+    return {
+        kind: 'append',
+        events: [
+            stateDraft(state, input, {
+                eventType: OrchestrationEventType.InstanceBlocked,
+                payload: { reason: AwaitTimeoutBlockReason },
+            }, 1),
+        ],
+    };
+}
 function requestLegacyReentry(events, definition, state, input) {
     const stage = definition.stages[stageName(state.currentStage)];
     events.push(stateDraft(state, input, {
@@ -70,6 +95,7 @@ function signalRejectionReason(state, input) {
 }
 function isBlockedHumanAuthorizedWait(state, signal, expected) {
     return (state.status === WorkflowStatus.Blocked &&
+        state.blockReason !== AwaitTimeoutBlockReason &&
         signal.authority?.kind === ApprovalAuthorityKind.Human &&
         expected.from?.some((authority) => authority.kind === ApprovalAuthorityKind.Human) === true);
 }

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

@@ -35,6 +35,9 @@ export function finishRoute(events, definition, state, input, route) {
                 from: route.await.from,
                 resume: route.await.resume,
                 onRejectResume: route.reentryTarget,
+                ...(route.await.timeoutMs === undefined
+                    ? {}
+                    : { timeoutMs: route.await.timeoutMs, waitStartedAt: input.occurredAt }),
             },
         }, events.length + 1));
         return;

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

@@ -177,6 +177,10 @@ function applySignalWaitStarted(state, event) {
     state.status = orchestrationStatusTransitions[OrchestrationEventType.SignalWaitStarted];
     state.waitingFor = {
         signalKind: event.payload.signalKind,
+        ...(event.payload.timeoutMs === undefined ? {} : { timeoutMs: event.payload.timeoutMs }),
+        ...(event.payload.waitStartedAt === undefined
+            ? {}
+            : { waitStartedAt: event.payload.waitStartedAt }),
         ...(event.payload.suppressWatchDispatch === true ? { suppressWatchDispatch: true } : {}),
         ...(event.payload.resourceId === undefined ? {} : { resourceId: event.payload.resourceId }),
         ...(event.payload.revision === undefined ? {} : { revision: event.payload.revision }),

package/package.json

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