@atolis-hq/wake 0.4.39 → 0.4.41

package/dist/src/activities/agent/agent-result.d.ts

@@ -39,5 +39,7 @@ export declare const agentActivityOutcomeSchema: z.ZodUnion<readonly [z.ZodObjec
     }, z.core.$strict>]>;
 }, z.core.$strict>]>;
 export type AgentActivityOutcome = z.output<typeof agentActivityOutcomeSchema>;
+/** Identifies the agent sentinel that explicitly asks a human for input. */
+export declare function isNeedsClarificationAgentOutcome(value: unknown): boolean;
 export declare const agentActivityOutcomeKinds: readonly ["done", "rejected", "blocked", "failed"];
 export declare function translateAgentResult(value: unknown): AgentActivityOutcome;

package/dist/src/activities/agent/agent-result.js

@@ -52,6 +52,14 @@ export const agentActivityOutcomeSchema = z.union([
     })
         .strict(),
 ]);
+/** Identifies the agent sentinel that explicitly asks a human for input. */
+export function isNeedsClarificationAgentOutcome(value) {
+    const parsed = agentActivityOutcomeSchema.safeParse(value);
+    return (parsed.success &&
+        parsed.data.kind === ActivityOutcomeKind.Blocked &&
+        'status' in parsed.data.data &&
+        parsed.data.data.status === 'NEEDS_CLARIFICATION');
+}
 export const agentActivityOutcomeKinds = [
     ActivityOutcomeKind.Done,
     ActivityOutcomeKind.Rejected,

package/dist/src/bootstrap/composition-root.js

@@ -127,7 +127,10 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
             : createTranscriptRetention(transcriptStore, projections, config, clock)),
         runnerIneligibility: createDurableRunnerIneligibility(journal, () => clock.now().toISOString()),
     });
-    const advanceOnce = activationScheduler.runOnce.bind(activationScheduler);
+    const advanceOnce = Object.assign(activationScheduler.runOnce.bind(activationScheduler), {
+        maintain: activationScheduler.maintain.bind(activationScheduler),
+        dispatch: activationScheduler.dispatch.bind(activationScheduler),
+    });
     const activationSchedulerSubscriber = createActivationSchedulerSubscriber(activationScheduler);
     const runtime = await composeIntegrationRuntime({
         config,

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.39";
+export const wakeVersion = "v0.4.41";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

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

@@ -1,8 +1,11 @@
 import { type Clock } from '../../kernel/index.js';
 import type { ResourceService } from '../../resources/index.js';
+import type { MaintenanceResult } from '../contracts/commands.js';
 import type { AdvanceOptions, AdvanceResult } from '../contracts/views.js';
 import type { ActivationSchedulerDependencies, ExecutionPort, OrchestrationPort } from './activation-scheduler-ports.js';
 export interface ActivationScheduler {
     runOnce(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
+    maintain?(signal?: AbortSignal): Promise<MaintenanceResult>;
+    dispatch?(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
 }
 export declare function createActivationScheduler(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): ActivationScheduler;

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

@@ -21,9 +21,7 @@ export function createActivationScheduler(orchestration, execution, resources, c
         occurredAt: clock.now().toISOString(),
         actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
     });
-    const run = async (options) => {
-        if (options.maxProgress < 1)
-            return { kind: 'exhausted', progressCount: 0 };
+    const maintain = async () => {
         if (await isDispatchPaused())
             return { kind: 'paused' };
         if (workspaceRecovery !== undefined) {
@@ -76,6 +74,13 @@ export function createActivationScheduler(orchestration, execution, resources, c
         if (await isDispatchPaused())
             return { kind: 'paused' };
         await orchestration.reconcileChildCompletions(context('child-completion-reconciliation'));
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        return { kind: 'ready' };
+    };
+    const dispatch = async (options) => {
+        if (options.maxProgress < 1)
+            return { kind: 'exhausted', progressCount: 0 };
         if (await isDispatchPaused())
             return { kind: 'paused' };
         const rawPending = await orchestration.listPendingActivations(options.workItemId);
@@ -146,7 +151,16 @@ export function createActivationScheduler(orchestration, execution, resources, c
         });
     };
     const serialise = dependencies.schedulerSerialiser ?? createInProcessSerialiser();
-    return { runOnce: (options, signal) => serialise(() => run(options), signal) };
+    return {
+        runOnce: (options, signal) => serialise(async () => {
+            if (options.maxProgress < 1)
+                return { kind: 'exhausted', progressCount: 0 };
+            const maintenance = await maintain();
+            return maintenance.kind === 'paused' ? { kind: 'paused' } : dispatch(options);
+        }, signal),
+        maintain: (signal) => serialise(maintain, signal),
+        dispatch: (options, signal) => serialise(() => dispatch(options), signal),
+    };
 }
 function createInProcessSerialiser() {
     let prior = Promise.resolve();

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

@@ -40,6 +40,10 @@ export async function runDispatchLoop(pending, ctx) {
     let stopReason;
     while (dispatched.length < ctx.maxDispatches) {
         const allRuns = await ctx.execution.list();
+        const activeActivationIds = new Set(allRuns.filter((run) => isActiveRunStatus(run.status)).map((run) => run.activationId));
+        const branchActiveWorkflowIds = new Set(allRuns
+            .filter((run) => isActiveRunStatus(run.status) && run.workspace?.mode === WorkspaceMode.Branch)
+            .map((run) => run.workflowInstanceId));
         if (allRuns.filter((run) => isActiveRunStatus(run.status)).length >= ctx.maxConcurrentRuns) {
             stopReason = { kind: 'no-work' };
             break;
@@ -49,10 +53,8 @@ export async function runDispatchLoop(pending, ctx) {
             activationId: item.activation.activationId,
             requestedPosition,
             hasActiveRun: dispatchedIds.has(item.activation.activationId) ||
-                (await ctx.execution.list(item.activation.activationId)).some((run) => isActiveRunStatus(run.status)) ||
-                allRuns.some((run) => isActiveRunStatus(run.status) &&
-                    run.workflowInstanceId === item.workflow.workflowInstanceId &&
-                    run.workspace?.mode === WorkspaceMode.Branch),
+                activeActivationIds.has(item.activation.activationId) ||
+                branchActiveWorkflowIds.has(item.workflow.workflowInstanceId),
             cancelled: false,
         }))))[0];
         const selected = selectedCandidate === undefined

package/dist/src/control-plane/application/advance-once.d.ts

@@ -2,4 +2,7 @@ import type { Clock } from '../../kernel/index.js';
 import type { ResourceService } from '../../resources/index.js';
 import type { ActivationSchedulerDependencies, ExecutionPort, OrchestrationPort } from './activation-scheduler-ports.js';
 /** Compatibility facade for callers that still use the former Advancement name. */
-export declare function createAdvanceOnce(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): (options: Parameters<(options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>>[0]) => Promise<import("../index.js").AdvanceResult>;
+export declare function createAdvanceOnce(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): ((options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>) & {
+    maintain: (signal?: AbortSignal) => Promise<import("../contracts/commands.js").MaintenanceResult>;
+    dispatch: (options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>;
+};

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

@@ -2,5 +2,8 @@ import { createActivationScheduler } from './activation-scheduler.js';
 /** Compatibility facade for callers that still use the former Advancement name. */
 export function createAdvanceOnce(orchestration, execution, resources, clock, dependencies) {
     const scheduler = createActivationScheduler(orchestration, execution, resources, clock, dependencies);
-    return (options) => scheduler.runOnce(options);
+    return Object.assign(scheduler.runOnce.bind(scheduler), {
+        maintain: scheduler.maintain.bind(scheduler),
+        dispatch: scheduler.dispatch.bind(scheduler),
+    });
 }

package/dist/src/control-plane/contracts/commands.d.ts

@@ -18,3 +18,12 @@ export interface HostResult {
     readonly stoppedBecause: 'idle' | typeof HostStopReason.Waiting | typeof HostStopReason.Blocked | 'budget' | 'paused' | typeof HostStopReason.Shutdown;
 }
 export type AdvanceOnce = (options: AdvanceOptions, signal?: AbortSignal) => Promise<AdvanceResult>;
+/** Optional scheduler phases used by hosts that can make several dispatch attempts in one pass. */
+export interface AdvancePhases {
+    maintain(signal?: AbortSignal): Promise<MaintenanceResult>;
+    dispatch(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
+}
+export type MaintenanceResult = {
+    readonly kind: 'ready' | 'paused';
+};
+export type PhasedAdvanceOnce = AdvanceOnce & Partial<AdvancePhases>;

package/dist/src/control-plane/infrastructure/tick-host.d.ts

@@ -1,6 +1,6 @@
-import { type AdvanceOnce, type HostBudget, type HostResult } from '../contracts/commands.js';
+import { type HostBudget, type HostResult, type PhasedAdvanceOnce } from '../contracts/commands.js';
 export declare class TickHost {
     private readonly advance;
-    constructor(advance: AdvanceOnce);
+    constructor(advance: PhasedAdvanceOnce);
     run(budget: HostBudget, signal?: AbortSignal): Promise<HostResult>;
 }

package/dist/src/control-plane/infrastructure/tick-host.js

@@ -9,10 +9,14 @@ export class TickHost {
         const started = Date.now();
         let advances = 0;
         let runs = 0;
+        const preparation = await prepareDispatch(this.advance, budget, started, signal);
+        if (preparation !== undefined)
+            return preparation;
+        const dispatch = this.advance.dispatch;
         while (advances < budget.maxAdvances && runs < budget.maxRuns) {
             if (Date.now() - started >= budget.maxDurationMs)
                 return { advances, runs, stoppedBecause: HostStopReason.Budget };
-            const result = await this.advance({ maxProgress: 1 }, signal);
+            const result = await (dispatch ?? this.advance)({ maxProgress: 1 }, signal);
             if (result.kind === 'progressed') {
                 advances += 1;
                 runs += result.dispatched.length;
@@ -33,3 +37,12 @@ export class TickHost {
         return { advances, runs, stoppedBecause: HostStopReason.Budget };
     }
 }
+async function prepareDispatch(advance, budget, started, signal) {
+    if (advance.dispatch === undefined || advance.maintain === undefined || budget.maxAdvances < 1)
+        return undefined;
+    if (Date.now() - started >= budget.maxDurationMs)
+        return { advances: 0, runs: 0, stoppedBecause: HostStopReason.Budget };
+    return (await advance.maintain(signal)).kind === 'paused'
+        ? { advances: 0, runs: 0, stoppedBecause: HostStopReason.Paused }
+        : undefined;
+}

package/dist/src/integrations/github/infrastructure/comment-source.js

@@ -5,18 +5,19 @@ import { mergeBatches, reportPartialPollFailure } from './poll-watermark.js';
 import { githubReviewObservation } from './review-source.js';
 export async function reviewCommentEventsFor(context, pullRequests) {
     if (context.client.listReviewComments === undefined)
-        return { drafts: [], succeeded: true };
+        return { drafts: [], succeeded: true, complete: true };
     const items = await Promise.all(pullRequests.map(async (pullRequest) => {
         try {
             const comments = await context.client.listReviewComments(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize, context.config.polling.maxPerRepo);
             return {
                 succeeded: true,
+                complete: comments.length < context.config.polling.maxPerRepo,
                 drafts: (await Promise.all(comments.map((comment) => issueCommentEventsForComment(context, pullRequest, comment)))).flat(),
             };
         }
         catch {
             reportPartialPollFailure(context.repository, `pull-request review comments #${pullRequest.number}`);
-            return { drafts: [], succeeded: false };
+            return { drafts: [], succeeded: false, complete: false };
         }
     }));
     return mergeBatches(items);
@@ -27,6 +28,7 @@ export async function reviewEventsFor(context, pullRequests) {
             const reviews = await context.client.listReviews(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize, context.config.polling.maxPerRepo);
             return {
                 succeeded: true,
+                complete: reviews.length < context.config.polling.maxPerRepo,
                 drafts: reviews.flatMap((review) => githubReviewObservation({
                     repository: context.repository,
                     pullRequest,
@@ -37,7 +39,7 @@ export async function reviewEventsFor(context, pullRequests) {
         }
         catch {
             reportPartialPollFailure(context.repository, `pull-request reviews #${pullRequest.number}`);
-            return { drafts: [], succeeded: false };
+            return { drafts: [], succeeded: false, complete: false };
         }
     }));
     return mergeBatches(items);
@@ -48,12 +50,13 @@ export async function issueCommentEventsFor(context, issues, since) {
             const comments = await context.client.listIssueComments(context.owner, context.repo, issue.number, context.config.polling.commentPageSize, since, context.config.polling.maxPerRepo);
             return {
                 succeeded: true,
+                complete: comments.length < context.config.polling.maxPerRepo,
                 drafts: (await Promise.all(comments.map((comment) => issueCommentEventsForComment(context, issue, comment)))).flat(),
             };
         }
         catch {
             reportPartialPollFailure(context.repository, `issue comments #${issue.number}`);
-            return { drafts: [], succeeded: false };
+            return { drafts: [], succeeded: false, complete: false };
         }
     }));
     return mergeBatches(items);

package/dist/src/integrations/github/infrastructure/poll-watermark.d.ts

@@ -1,12 +1,36 @@
 import type { CheckpointStore } from '@atolis-hq/eventing';
 import type { AdapterId } from '../../contracts/identifiers.js';
 import type { GitHubAdapterEventData } from '../contracts/events.js';
+export declare const minimumPollOverlapMs: number;
 export interface PollBatch {
     readonly drafts: readonly GitHubAdapterEventData[];
     readonly succeeded: boolean;
+    readonly complete: boolean;
 }
 export declare function mergeBatches(batches: readonly PollBatch[]): PollBatch;
 export declare function watermarkCheckpoint(adapter: AdapterId | undefined, repository: string): string;
 export declare function loadWatermark(checkpoints: CheckpointStore | undefined, adapter: AdapterId | undefined, owner: string, repo: string): Promise<number>;
 export declare function overlapSince(watermark: number, overlapMs: number): string | undefined;
+export declare function providerWatermark(previous: number, updatedAts: readonly string[]): number | undefined;
+export declare function hasProviderTimestamp(payload: {
+    readonly updated_at: string;
+}): boolean;
+export declare function timestampsValid(...groups: readonly (readonly {
+    readonly updated_at: string;
+}[])[]): boolean;
+export declare function batchesSucceeded(batches: readonly PollBatch[]): boolean;
+export declare function batchesComplete(batches: readonly PollBatch[]): boolean;
+export declare function completedProviderWatermark(input: {
+    readonly previous: number;
+    readonly maximumResults: number;
+    readonly issues: readonly {
+        readonly updated_at: string;
+    }[];
+    readonly pullRequests: readonly {
+        readonly updated_at: string;
+    }[];
+    readonly topLevelSucceeded: boolean;
+    readonly topLevelTimestampsValid: boolean;
+    readonly nestedBatches: readonly PollBatch[];
+}): number | undefined;
 export declare function reportPartialPollFailure(repository: string, query: string): void;

package/dist/src/integrations/github/infrastructure/poll-watermark.js

@@ -1,7 +1,9 @@
+export const minimumPollOverlapMs = 5 * 60_000;
 export function mergeBatches(batches) {
     return {
         drafts: batches.flatMap((batch) => batch.drafts),
         succeeded: batches.every((batch) => batch.succeeded),
+        complete: batches.every((batch) => batch.complete),
     };
 }
 export function watermarkCheckpoint(adapter, repository) {
@@ -15,7 +17,41 @@ export async function loadWatermark(checkpoints, adapter, owner, repo) {
 export function overlapSince(watermark, overlapMs) {
     if (!Number.isFinite(watermark) || watermark <= 0)
         return undefined;
-    return new Date(Math.max(0, watermark - overlapMs)).toISOString();
+    return new Date(Math.max(0, watermark - Math.max(overlapMs, minimumPollOverlapMs))).toISOString();
+}
+export function providerWatermark(previous, updatedAts) {
+    const latest = updatedAts.reduce((current, updatedAt) => {
+        const timestamp = Date.parse(updatedAt);
+        if (!Number.isFinite(timestamp) || timestamp < previous)
+            return current;
+        return current === undefined || timestamp > current ? timestamp : current;
+    }, undefined);
+    return latest === undefined || latest === previous ? undefined : latest;
+}
+export function hasProviderTimestamp(payload) {
+    return Number.isFinite(Date.parse(payload.updated_at));
+}
+export function timestampsValid(...groups) {
+    return groups.flat().every(hasProviderTimestamp);
+}
+export function batchesSucceeded(batches) {
+    return batches.every((batch) => batch.succeeded);
+}
+export function batchesComplete(batches) {
+    return batches.every((batch) => batch.complete);
+}
+export function completedProviderWatermark(input) {
+    if (!input.topLevelSucceeded ||
+        !input.topLevelTimestampsValid ||
+        !batchesSucceeded(input.nestedBatches) ||
+        !batchesComplete(input.nestedBatches) ||
+        input.issues.length >= input.maximumResults ||
+        input.pullRequests.length >= input.maximumResults)
+        return undefined;
+    return providerWatermark(input.previous, [
+        ...input.issues.map((issue) => issue.updated_at),
+        ...input.pullRequests.map((pullRequest) => pullRequest.updated_at),
+    ]);
 }
 export function reportPartialPollFailure(repository, query) {
     process.stderr.write(`GitHub poll partial failure for ${repository}: ${query}; preserving watermark for replay\n`);

package/dist/src/integrations/github/infrastructure/pr-evidence.d.ts

@@ -0,0 +1,18 @@
+import type { GitHubCheckRunPayload, GitHubCommitStatusPayload } from '../contracts/payloads.js';
+export interface CheckEvidence {
+    readonly available: boolean;
+    readonly complete: boolean;
+    readonly checkRuns: readonly GitHubCheckRunPayload[];
+    readonly statuses: readonly GitHubCommitStatusPayload[];
+}
+export interface ChangedFiles {
+    readonly files: readonly string[] | undefined;
+    readonly complete: boolean;
+}
+interface PullRequestEvidenceClient {
+    listCheckRunsForRef(owner: string, repo: string, ref: string, maxResults?: number): Promise<readonly GitHubCheckRunPayload[]>;
+    getCombinedStatusForRef(owner: string, repo: string, ref: string, maxResults?: number): Promise<readonly GitHubCommitStatusPayload[]>;
+    listPullRequestFiles(owner: string, repo: string, pullNumber: number, maxResults?: number): Promise<readonly string[]>;
+}
+export declare function readPullRequestEvidence(client: PullRequestEvidenceClient, owner: string, repo: string, headRevision: string, pullNumber: number, maxResults: number): Promise<readonly [CheckEvidence, ChangedFiles]>;
+export {};

package/dist/src/integrations/github/infrastructure/pr-evidence.js

@@ -0,0 +1,32 @@
+export async function readPullRequestEvidence(client, owner, repo, headRevision, pullNumber, maxResults) {
+    return Promise.all([
+        readCheckEvidence(client, owner, repo, headRevision, maxResults),
+        readChangedFiles(client, owner, repo, pullNumber, maxResults),
+    ]);
+}
+async function readCheckEvidence(client, owner, repo, headRevision, maxResults) {
+    try {
+        const [checkRuns, statuses] = await Promise.all([
+            client.listCheckRunsForRef(owner, repo, headRevision, maxResults),
+            client.getCombinedStatusForRef(owner, repo, headRevision, maxResults),
+        ]);
+        return {
+            available: true,
+            complete: checkRuns.length < maxResults && statuses.length < maxResults,
+            checkRuns,
+            statuses,
+        };
+    }
+    catch {
+        return { available: false, complete: false, checkRuns: [], statuses: [] };
+    }
+}
+async function readChangedFiles(client, owner, repo, pullNumber, maxResults) {
+    try {
+        const files = await client.listPullRequestFiles(owner, repo, pullNumber, maxResults);
+        return { files, complete: files.length < maxResults };
+    }
+    catch {
+        return { files: undefined, complete: false };
+    }
+}

package/dist/src/integrations/github/infrastructure/pr-source.d.ts

@@ -1,16 +1,20 @@
 import type { AdapterId } from '../../contracts/identifiers.js';
 import type { ExternalEventSource } from '../application/poll-service.js';
 import { type GitHubCheckRunPayload, type GitHubCommitStatusPayload, type GitHubPullRequestPayload } from '../contracts/payloads.js';
+import type { PollBatch } from './poll-watermark.js';
 export interface GitHubPullRequestSourceClient {
     listPullRequests(owner: string, repo: string, maxResults: number): Promise<readonly GitHubPullRequestPayload[]>;
     listCheckRunsForRef(owner: string, repo: string, ref: string, maxResults?: number): Promise<readonly GitHubCheckRunPayload[]>;
     getCombinedStatusForRef(owner: string, repo: string, ref: string, maxResults?: number): Promise<readonly GitHubCommitStatusPayload[]>;
     listPullRequestFiles(owner: string, repo: string, pullNumber: number, maxResults?: number): Promise<readonly string[]>;
 }
-export declare function createGitHubPullRequestSource(input: {
+interface GitHubPullRequestSourceInput {
     readonly client: GitHubPullRequestSourceClient;
     readonly repository: string;
     readonly maxResults: number;
     readonly maxConcurrency?: number;
     readonly adapter?: AdapterId;
-}): ExternalEventSource;
+}
+export declare function createGitHubPullRequestSource(input: GitHubPullRequestSourceInput): ExternalEventSource;
+export declare function pullRequestEventsFor(input: GitHubPullRequestSourceInput, signal: AbortSignal): Promise<PollBatch>;
+export {};

package/dist/src/integrations/github/infrastructure/pr-source.js

@@ -8,30 +8,39 @@ import { formatGitHubResourceKey } from '../contracts/external-key.js';
 import { gitHubAssigneeLogins, gitHubLabelNames, } from '../contracts/payloads.js';
 import { GitHubAdapter, GitHubCheckRunStatus, UnknownGitHubIdentity, UnknownGitHubRevision, } from '../contracts/vocabulary.js';
 import { withoutWakeMarkers } from './content-fingerprint.js';
+import { readPullRequestEvidence } from './pr-evidence.js';
 export function createGitHubPullRequestSource(input) {
-    const { owner, repo } = parseRepository(input.repository);
     return {
         async poll(signal) {
-            signal.throwIfAborted();
-            const pullRequests = await input.client.listPullRequests(owner, repo, input.maxResults);
-            return mapConcurrent(pullRequests, input.maxConcurrency ?? 4, async (pullRequest) => {
-                signal.throwIfAborted();
-                const headRevision = fallback(pullRequest.head?.sha, pullRequest.updated_at);
-                const [evidence, changedFiles] = await Promise.all([
-                    readCheckEvidence(input.client, owner, repo, headRevision, input.maxResults),
-                    readChangedFiles(input.client, owner, repo, pullRequest.number, input.maxResults),
-                ]);
-                return pullRequestObservation({
-                    repository: input.repository,
-                    pullRequest,
-                    evidence,
-                    changedFiles,
-                    ...(input.adapter === undefined ? {} : { adapter: input.adapter }),
-                });
-            });
+            return (await pullRequestEventsFor(input, signal)).drafts;
         },
     };
 }
+export async function pullRequestEventsFor(input, signal) {
+    const { owner, repo } = parseRepository(input.repository);
+    signal.throwIfAborted();
+    const pullRequests = await input.client.listPullRequests(owner, repo, input.maxResults);
+    const results = await mapConcurrent(pullRequests, input.maxConcurrency ?? 4, async (pullRequest) => {
+        signal.throwIfAborted();
+        const headRevision = fallback(pullRequest.head?.sha, pullRequest.updated_at);
+        const [evidence, changedFiles] = await readPullRequestEvidence(input.client, owner, repo, headRevision, pullRequest.number, input.maxResults);
+        return {
+            complete: evidence.complete && changedFiles.complete,
+            draft: pullRequestObservation({
+                repository: input.repository,
+                pullRequest,
+                evidence,
+                changedFiles: changedFiles.files,
+                ...(input.adapter === undefined ? {} : { adapter: input.adapter }),
+            }),
+        };
+    });
+    return {
+        drafts: results.map((result) => result.draft),
+        succeeded: true,
+        complete: results.every((result) => result.complete),
+    };
+}
 function pullRequestObservation(input) {
     const pullRequest = input.pullRequest;
     const key = formatGitHubResourceKey({
@@ -93,26 +102,6 @@ function normalizeCheckEvidence(checkRuns, statuses) {
         return PullRequestCheckState.Passing;
     return PullRequestCheckState.Unknown;
 }
-async function readCheckEvidence(client, owner, repo, headRevision, maxResults) {
-    try {
-        const [checkRuns, statuses] = await Promise.all([
-            client.listCheckRunsForRef(owner, repo, headRevision, maxResults),
-            client.getCombinedStatusForRef(owner, repo, headRevision, maxResults),
-        ]);
-        return { available: true, checkRuns, statuses };
-    }
-    catch {
-        return { available: false, checkRuns: [], statuses: [] };
-    }
-}
-async function readChangedFiles(client, owner, repo, pullNumber, maxResults) {
-    try {
-        return await client.listPullRequestFiles(owner, repo, pullNumber, maxResults);
-    }
-    catch {
-        return undefined;
-    }
-}
 async function mapConcurrent(values, concurrency, transform) {
     const output = new Array(values.length);
     let nextIndex = 0;

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

@@ -3,8 +3,8 @@ import { GitHubEventType } from '../contracts/events.js';
 import { createGitHubAdapterHealthRegistry, } from './adapter-health-registry.js';
 import { issueCommentEventsFor, reviewCommentEventsFor, reviewEventsFor, } from './comment-source.js';
 import { issueObservation } from './issue-source.js';
-import { loadWatermark, overlapSince, reportPartialPollFailure, watermarkCheckpoint, } from './poll-watermark.js';
-import { createGitHubPullRequestSource } from './pr-source.js';
+import { batchesComplete, batchesSucceeded, completedProviderWatermark, hasProviderTimestamp, loadWatermark, overlapSince, reportPartialPollFailure, timestampsValid, watermarkCheckpoint, } from './poll-watermark.js';
+import { pullRequestEventsFor } from './pr-source.js';
 import { createGitHubRequestCoordinator, } from './request-coordinator.js';
 export function createGitHubSource(config, client, adapter, requests = createGitHubRequestCoordinator({
     maxConcurrent: config.polling.maxConcurrent,
@@ -36,12 +36,11 @@ export function createGitHubSource(config, client, adapter, requests = createGit
                 owner,
                 repo,
                 watermark: await loadWatermark(state?.checkpoints, adapter, owner, repo),
-                now,
                 health,
             })));
             for (const result of perRepository)
-                if (result.succeeded)
-                    pendingWatermarks.set(result.repository, result.completedAt);
+                if (result.watermark !== undefined)
+                    pendingWatermarks.set(result.repository, result.watermark);
             return perRepository
                 .flatMap((result) => result.drafts)
                 .filter((draft) => {
@@ -87,15 +86,7 @@ function limitGitHubSourceClient(client, requests) {
 }
 async function pollRepository(input) {
     const { client, config, adapter, signal, owner, repo, health } = input;
-    const queriedAt = input.now();
-    const context = {
-        client,
-        config,
-        adapter,
-        owner,
-        repo,
-        repository: `${owner}/${repo}`,
-    };
+    const context = createRepositoryPollContext(client, config, adapter, owner, repo);
     const since = overlapSince(input.watermark, config.polling.lookbackMs);
     const [issuesResult, pullRequestsResult] = await fetchRepositoryItems({
         client,
@@ -105,29 +96,43 @@ async function pollRepository(input) {
         since,
     });
     reportRepositoryReadResults(context, health, issuesResult, pullRequestsResult);
-    const issues = isFulfilled(issuesResult) ? issuesResult.value : [];
-    const pullRequestPayloads = isFulfilled(pullRequestsResult)
-        ? pullRequestsResult.value.filter((pullRequest) => since === undefined || pullRequest.updated_at >= since)
+    const returnedIssues = isFulfilled(issuesResult) ? issuesResult.value : [];
+    const issues = returnedIssues.filter(hasProviderTimestamp);
+    const returnedPullRequestPayloads = isFulfilled(pullRequestsResult)
+        ? pullRequestsResult.value
         : [];
+    const topLevelTimestampsValid = timestampsValid(returnedIssues, returnedPullRequestPayloads);
+    const pullRequestPayloads = returnedPullRequestPayloads
+        .filter(hasProviderTimestamp)
+        .filter((pullRequest) => since === undefined || pullRequest.updated_at >= since);
     const [pullRequests, reviews, reviewComments, issueComments] = await Promise.all([
-        createGitHubPullRequestSource({
+        pullRequestEventsFor({
             client: { ...client, listPullRequests: async () => pullRequestPayloads },
             repository: context.repository,
             maxResults: config.polling.maxPerRepo,
             ...(adapter === undefined ? {} : { adapter }),
-        }).poll(signal),
+        }, signal),
         reviewEventsFor(context, pullRequestPayloads),
         reviewCommentEventsFor(context, pullRequestPayloads),
         issueCommentEventsFor(context, [...issues, ...pullRequestPayloads], since),
     ]);
+    const nestedBatches = [pullRequests, reviews, reviewComments, issueComments];
     return {
         repository: context.repository,
-        completedAt: queriedAt,
-        succeeded: isFulfilled(issuesResult) &&
+        watermark: completedProviderWatermark({
+            previous: input.watermark,
+            maximumResults: config.polling.maxPerRepo,
+            issues: returnedIssues,
+            pullRequests: returnedPullRequestPayloads,
+            topLevelSucceeded: isFulfilled(issuesResult) && isFulfilled(pullRequestsResult),
+            topLevelTimestampsValid,
+            nestedBatches,
+        }),
+        succeeded: topLevelTimestampsValid &&
+            isFulfilled(issuesResult) &&
             isFulfilled(pullRequestsResult) &&
-            reviews.succeeded &&
-            reviewComments.succeeded &&
-            issueComments.succeeded,
+            batchesComplete(nestedBatches) &&
+            batchesSucceeded(nestedBatches),
         drafts: [
             ...issues
                 .filter((issue) => issue.pull_request === undefined)
@@ -136,13 +141,16 @@ async function pollRepository(input) {
                 issue,
                 ...(adapter === undefined ? {} : { adapter }),
             })),
-            ...pullRequests,
+            ...pullRequests.drafts,
             ...reviews.drafts,
             ...reviewComments.drafts,
             ...issueComments.drafts,
         ],
     };
 }
+function createRepositoryPollContext(client, config, adapter, owner, repo) {
+    return { client, config, adapter, owner, repo, repository: `${owner}/${repo}` };
+}
 function fetchRepositoryItems(input) {
     const { client, config, owner, repo, since } = input;
     return Promise.allSettled([

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

@@ -31,6 +31,7 @@ export declare class AdvanceWorkflow {
     restartBlockedFailedStage(id: WorkflowInstanceId, context: CommandContext): Promise<import("../index.js").WorkflowInstanceView>;
     private retryBlockedFailedStageWith;
     resumeBlockedStageForChanges(id: WorkflowInstanceId, context: CommandContext): Promise<import("../index.js").WorkflowInstanceView | null>;
+    resumeNeedsClarificationStage(id: WorkflowInstanceId, context: CommandContext): Promise<import("../index.js").WorkflowInstanceView | null>;
     get(id: WorkflowInstanceId): Promise<import("../index.js").WorkflowInstanceView | null>;
     listPendingActivations(workItemId?: string): Promise<{
         workflow: import("../index.js").WorkflowInstanceView;

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

@@ -3,7 +3,7 @@ import { OrchestrationEventType } from '../contracts/events.js';
 import { commandName } from '../contracts/identifiers.js';
 import { WorkflowStatus } from '../contracts/vocabulary.js';
 import { workflowEventData } from '../domain/decision-events.js';
-import { requestChangesResume as decideChangesResume, requestFreshOperatorRetry as decideFreshOperatorRetry, requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, requestRunnerQuotaRetry, } from '../domain/interpreter.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 { acceptResourceTransition, matchResourceTransitions, } from './resource-transition-matching.js';
@@ -190,6 +190,12 @@ export class AdvanceWorkflow {
             return recovered.view;
         return (await this.repository.loadRequired(id)).view;
     }
+    async resumeNeedsClarificationStage(id, context) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null || !isNeedsClarificationResumeEligible(loaded.view))
+            return loaded.view;
+        return this.resumeBlockedStageForChanges(id, context);
+    }
     async get(id) {
         return (await this.repository.load(id)).view;
     }

package/dist/src/orchestration/application/conversation-command-reactor.js

@@ -41,12 +41,15 @@ export function createConversationCommandReactor(orchestration) {
                     occurredAt: event.occurredAt,
                     actor: { kind: EventActorKind.Integration, id: entry.origin.adapter },
                 });
-                if (conversationCommand(entry.body) !== null || !input.authorized)
+                if (conversationCommand(entry.body) !== null)
                     return;
                 for (const workflow of await orchestration.listAll()) {
                     if (workflow.workItemId !== workItemId)
                         continue;
-                    await orchestration.resumeBlockedStageForChanges(workflow.workflowInstanceId, {
+                    const resume = input.authorized
+                        ? orchestration.resumeBlockedStageForChanges.bind(orchestration)
+                        : orchestration.resumeNeedsClarificationStage.bind(orchestration);
+                    await resume(workflow.workflowInstanceId, {
                         commandId: `${event.eventId}:conversation-reply`,
                         correlationId: correlationId(event.correlationId),
                         occurredAt: event.occurredAt,

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

@@ -61,6 +61,7 @@ export declare class OrchestrationService {
     retryBlockedFailedStage(workflowInstanceId: WorkflowInstanceId, context: CommandContext): Promise<WorkflowInstanceView>;
     restartBlockedFailedStage(workflowInstanceId: WorkflowInstanceId, context: CommandContext): Promise<WorkflowInstanceView>;
     resumeBlockedStageForChanges(workflowInstanceId: WorkflowInstanceId, context: CommandContext): Promise<WorkflowInstanceView | null>;
+    resumeNeedsClarificationStage(workflowInstanceId: WorkflowInstanceId, context: CommandContext): Promise<WorkflowInstanceView | null>;
     extendBlockedGroupBudget(workflowInstanceId: WorkflowInstanceId, authority: {
         readonly kind: string;
     }, context: CommandContext): Promise<import("../contracts/views.js").GroupBudgetExhaustedView | WorkflowInstanceView>;

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

@@ -137,6 +137,9 @@ export class OrchestrationService {
     resumeBlockedStageForChanges(workflowInstanceId, context) {
         return this.transitionWatchChildren(context, () => this.advanceWorkflow.resumeBlockedStageForChanges(workflowInstanceId, context));
     }
+    resumeNeedsClarificationStage(workflowInstanceId, context) {
+        return this.transitionWatchChildren(context, () => this.advanceWorkflow.resumeNeedsClarificationStage(workflowInstanceId, context));
+    }
     async extendBlockedGroupBudget(workflowInstanceId, authority, context) {
         if (authority.kind !== ApprovalAuthorityKind.Human)
             throw new GroupBudgetExtensionIneligibleError('A group budget extension requires human authority');

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

@@ -7,7 +7,7 @@ export { acceptSignal, 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';
-export { isChangesResumeEligible, isGroupBudgetExtensionEligible, isOperatorRetryEligible, requestChangesResume, requestFreshOperatorRetry, requestOperatorRetry, selectOperatorRetryTarget, } from './operator-retry-policy.js';
+export { isChangesResumeEligible, isGroupBudgetExtensionEligible, isNeedsClarificationResumeEligible, isOperatorRetryEligible, requestChangesResume, requestFreshOperatorRetry, requestOperatorRetry, selectOperatorRetryTarget, } from './operator-retry-policy.js';
 export type { OperatorRetryRequest } from './operator-retry-policy.js';
 export { isRunnerQuotaRetryEligible, requestRunnerQuotaRetry, } from './runner-quota-retry-policy.js';
 export type { RunnerQuotaRetryRequest } from './runner-quota-retry-policy.js';

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, isGroupBudgetExtensionEligible, isOperatorRetryEligible, requestChangesResume, requestFreshOperatorRetry, requestOperatorRetry, selectOperatorRetryTarget, } from './operator-retry-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';
 export function acceptActivityOutcome(definition, state, input) {
     if (!isPendingOutcome(state, input))

package/dist/src/orchestration/domain/operator-retry-policy.d.ts

@@ -7,6 +7,8 @@ export interface OperatorRetryRequest extends DecisionContext {
 export declare function isOperatorRetryEligible(view: WorkflowInstanceView): boolean;
 export declare function selectOperatorRetryTarget(workflows: readonly WorkflowInstanceView[]): WorkflowInstanceView | undefined;
 export declare function isChangesResumeEligible(view: WorkflowInstanceView): boolean;
+/** A clarification reply may be supplied by any conversation participant. */
+export declare function isNeedsClarificationResumeEligible(view: WorkflowInstanceView): boolean;
 export declare function isGroupBudgetExtensionEligible(view: WorkflowInstanceView): boolean;
 export declare function requestOperatorRetry(definition: CompiledWorkflow, state: WorkflowInstanceView, input: OperatorRetryRequest): OrchestrationDecision;
 /** Re-requests the failed stage while requiring a new runner session. */

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

@@ -1,4 +1,4 @@
-import { ActivityOutcomeKind, BuiltInActivityName } from '../../activities/index.js';
+import { ActivityOutcomeKind, BuiltInActivityName, isNeedsClarificationAgentOutcome, } from '../../activities/index.js';
 import { OrchestrationEventType, WatchGateVerdictSignal } from '../contracts/events.js';
 import { signalName, stageName, watchId } from '../contracts/identifiers.js';
 import { ActivityActivationStatus, ApprovalAuthorityKind, WorkflowStatus, } from '../contracts/vocabulary.js';
@@ -49,20 +49,26 @@ export function selectOperatorRetryTarget(workflows) {
         isOperatorRetryEligible(workflow));
 }
 export function isChangesResumeEligible(view) {
-    const pending = view.pendingActivation;
-    const completedAgentStage = pending !== undefined &&
-        pending.activity === BuiltInActivityName.Agent &&
-        pending.status === ActivityActivationStatus.Completed &&
-        pending.supplemental !== true &&
-        pending.followOnIndex === undefined &&
-        view.acceptedOutcomes.includes(pending.activationId);
-    if (!completedAgentStage)
+    if (!isCompletedAgentStage(view))
         return false;
     return ((view.status === WorkflowStatus.Blocked &&
         view.blockReason === 'unconfigured outcome blocked' &&
         view.lastOutcome?.kind === ActivityOutcomeKind.Blocked) ||
         (view.status === WorkflowStatus.Waiting && view.waitingFor !== undefined));
 }
+/** A clarification reply may be supplied by any conversation participant. */
+export function isNeedsClarificationResumeEligible(view) {
+    return isChangesResumeEligible(view) && isNeedsClarificationAgentOutcome(view.lastOutcome);
+}
+function isCompletedAgentStage(view) {
+    const pending = view.pendingActivation;
+    return (pending !== undefined &&
+        pending.activity === BuiltInActivityName.Agent &&
+        pending.status === ActivityActivationStatus.Completed &&
+        pending.supplemental !== true &&
+        pending.followOnIndex === undefined &&
+        view.acceptedOutcomes.includes(pending.activationId));
+}
 export function isGroupBudgetExtensionEligible(view) {
     return (view.status === WorkflowStatus.Blocked &&
         view.blockReason?.startsWith('watch group budget exhausted for ') === true &&

package/package.json

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