@atolis-hq/wake 0.4.41 → 0.4.43

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/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.41";
+export const wakeVersion = "v0.4.43";
 /** 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/integrations/github/application/inbound-watch-gate-signals.js

@@ -35,9 +35,7 @@ function extractMarker(body) {
 function translateOutcome(outcome) {
     if (outcome === 'DONE')
         return ActivityOutcomeKind.Done;
-    if (outcome === 'REJECTED')
-        return ActivityOutcomeKind.Rejected;
-    return null;
+    return ActivityOutcomeKind.Rejected;
 }
 export async function applyWatchGateVerdictSignal(input) {
     const { event, runs, orchestration } = input;
@@ -47,8 +45,6 @@ export async function applyWatchGateVerdictSignal(input) {
     if (marker === null)
         return;
     const outcome = translateOutcome(marker.outcome);
-    if (outcome === null)
-        return;
     const verdict = await verifyWatchGateVerdict({ marker, outcome, runs, orchestration });
     if (verdict === null)
         return;
@@ -66,7 +62,9 @@ async function verifyWatchGateVerdict(input) {
     const run = (await runs.load(runId(marker.runId))).view;
     if (run === null)
         return null;
-    if (run.status !== RunStatus.Succeeded || run.outcome?.kind !== outcome)
+    if (run.status !== RunStatus.Succeeded ||
+        run.outcome === undefined ||
+        translateOutcome(run.outcome.kind.toUpperCase()) !== outcome)
         return null;
     const workflows = await orchestration.listAll();
     const child = workflows.find((workflow) => workflow.workflowInstanceId === run.workflowInstanceId);

package/dist/src/integrations/github/infrastructure/client-reads.d.ts

@@ -3,6 +3,7 @@ import { PullRequestState } from '../../../activities/index.js';
 import type { GitHubIssueQueryFilters } from '../contracts/issue-query.js';
 import type { GitHubIssueCommentPayload, GitHubIssuePayload } from '../contracts/payloads.js';
 import type { createEtagCache } from './etag-cache.js';
+export declare function findIssueCommentByMarker(octokit: Octokit, owner: string, repo: string, issueNumber: number, marker: string): Promise<string | null>;
 export declare function listIssues(octokit: Octokit, cache: ReturnType<typeof createEtagCache>, owner: string, repo: string, maxResults: number, options?: {
     readonly since?: string;
     readonly filters?: GitHubIssueQueryFilters;

package/dist/src/integrations/github/infrastructure/client-reads.js

@@ -2,6 +2,22 @@
 import { PullRequestState } from '../../../activities/index.js';
 import { GitHubListState } from '../contracts/vocabulary.js';
 import { fetchPaginatedWithEtag, fetchWithEtag } from './etag-cache.js';
+export async function findIssueCommentByMarker(octokit, owner, repo, issueNumber, marker) {
+    for await (const page of octokit.paginate.iterator(octokit.rest.issues.listComments, {
+        owner,
+        repo,
+        issue_number: issueNumber,
+        per_page: 100,
+    })) {
+        const comment = page.data.find((value) => value.body?.includes(marker));
+        if (comment !== undefined) {
+            if (!Number.isSafeInteger(comment.id) || comment.id <= 0)
+                throw new Error('GitHub comment marker lookup returned an invalid comment id');
+            return String(comment.id);
+        }
+    }
+    return null;
+}
 export function listIssues(octokit, cache, owner, repo, maxResults, options = {}) {
     const { since, filters = {} } = options;
     return fetchPaginatedWithEtag({

package/dist/src/integrations/github/infrastructure/client.js

@@ -2,8 +2,9 @@ import { Octokit } from '@octokit/rest';
 import { MergeMethod, ProviderPermission, PullRequestState } from '../../../activities/index.js';
 import { GitHubOutboundAction } from '../contracts/vocabulary.js';
 import { createBoundedGitHubFetch } from './bounded-fetch.js';
-import { branch, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequestFiles, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
+import { branch, findIssueCommentByMarker, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequestFiles, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
 import { createEtagCache } from './etag-cache.js';
+/* eslint-disable max-lines */
 // Octokit's request-log plugin reports every non-2xx response through this
 // callback, including the expected 304 responses produced by conditional ETag
 // reads. Keep those cache hits quiet, but retain a small, safe operator signal
@@ -169,6 +170,9 @@ async function deliver(octokit, command) {
     const issueNumber = command.issue_number ?? command.pull_number;
     if (issueNumber === undefined)
         throw new Error('GitHub comment requires an issue or pull request');
+    const existingCommentId = await findIssueCommentByMarker(octokit, command.owner, command.repo, issueNumber, marker);
+    if (existingCommentId !== null)
+        return existingCommentId;
     const response = await octokit.rest.issues.createComment({
         owner: command.owner,
         repo: command.repo,

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/application/request-child.js

@@ -177,8 +177,7 @@ function watchIdsFor(wait) {
 function watchGateVerdictOutcome(parent, child) {
     if (parent.waitingFor?.signalKind !== WatchGateVerdictSignal)
         return undefined;
-    return child.lastOutcome?.kind === ActivityOutcomeKind.Done ||
-        child.lastOutcome?.kind === ActivityOutcomeKind.Rejected
-        ? child.lastOutcome.kind
-        : undefined;
+    return child.lastOutcome?.kind === ActivityOutcomeKind.Done
+        ? ActivityOutcomeKind.Done
+        : ActivityOutcomeKind.Rejected;
 }

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