@atolis-hq/wake 0.4.38 → 0.4.40

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/surface-api-applications.js

@@ -279,6 +279,19 @@ function createSystemApplications(root, now) {
                 meta: sampledMeta(sampledAt),
             };
         },
+        async webhooks() {
+            const sampledAt = now();
+            const adapters = await Promise.all(root.providers.flatMap((instance) => instance.webhook === undefined
+                ? []
+                : [
+                    instance.webhook.setupInstructions().then((hooks) => ({
+                        adapter: instance.adapter,
+                        provider: instance.provider,
+                        hooks,
+                    })),
+                ]));
+            return { data: { adapters }, meta: sampledMeta(sampledAt) };
+        },
     };
 }
 function commandAccepted(command, acceptedAt) {

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

package/dist/src/integrations/contracts/provider.d.ts

@@ -2,7 +2,7 @@ import type { CheckpointStore, EventJournal } from '@atolis-hq/eventing';
 import type { PullRequestService } from '../../activities/index.js';
 import type { ConversationService } from '../../conversations/index.js';
 import type { RunRepository } from '../../execution/index.js';
-import type { Clock, IdGenerator } from '../../kernel/index.js';
+import { type Clock, type IdGenerator, type ValueOf } from '../../kernel/index.js';
 import type { OrchestrationService, SurfaceCapability, WorkflowCandidate, WorkflowName } from '../../orchestration/index.js';
 import type { ExternalResourceKey, ResourceCapability, ResourceKind, ResourceLookup, ResourceService } from '../../resources/index.js';
 import type { WorkItemId, WorkItemView, WorkService } from '../../work/index.js';
@@ -44,10 +44,14 @@ export interface VerifiedArtifact {
     readonly capabilities: readonly ResourceCapability[];
     readonly revision?: string | undefined;
 }
+export declare const AdapterHealthStatus: {
+    readonly Unknown: "unknown";
+};
+export type AdapterHealthStatus = 'ok' | 'degraded' | ValueOf<typeof AdapterHealthStatus>;
 export interface AdapterHealthCheck {
     readonly scope: string;
     readonly channel: string;
-    readonly status: 'ok' | 'degraded';
+    readonly status: AdapterHealthStatus;
     readonly detail?: string;
     readonly successCount: number;
     readonly failureCount: number;
@@ -79,8 +83,16 @@ export interface ProviderInstance {
 }
 export interface ProviderWebhook {
     provision(): Promise<void>;
+    setupInstructions(): Promise<readonly ProviderWebhookSetup[]>;
     receive(body: Buffer, headers: Readonly<Record<string, string | string[] | undefined>>, trigger: () => void): Promise<404 | 400 | 401 | 202>;
 }
+/** Operator-only material for configuring a provider webhook outside Wake. */
+export interface ProviderWebhookSetup {
+    readonly scope: string;
+    readonly endpoint: string;
+    readonly events: readonly string[];
+    readonly secret: string;
+}
 export type ComposedProviderInstance = Omit<ProviderInstance, 'provider'>;
 export interface ProviderDefinition<Config = unknown> {
     readonly provider: string;

package/dist/src/integrations/contracts/provider.js

@@ -1,4 +1,8 @@
+import { defineClosedVocabulary, } from '../../kernel/index.js';
 import { adapterId } from './identifiers.js';
+export const AdapterHealthStatus = defineClosedVocabulary({
+    Unknown: 'unknown',
+});
 export class ProviderRegistry {
     definitions = new Map();
     register(definition) {

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/integrations/github/infrastructure/webhook.js

@@ -55,10 +55,21 @@ export function createGitHubWebhook(adapter, config, publicUrl, root, client, he
                     return 401;
                 if (!events.has(event))
                     return 404;
+                health.recordSuccess(`${owner}/${repo}`, 'webhook');
                 trigger();
                 return 202;
             });
         },
+        async setupInstructions() {
+            if (!config.webhooks.enabled || endpoint === undefined)
+                return [];
+            return Promise.all(config.repositories.map(({ owner, repo }) => state.serialise(owner, repo, async () => ({
+                scope: `${owner}/${repo}`,
+                endpoint,
+                events: [...events],
+                secret: (await state.load(owner, repo)).secret,
+            }))));
+        },
     };
 }
 async function provisionRepository(repository, endpoint, state, client, health) {
@@ -67,7 +78,6 @@ async function provisionRepository(repository, endpoint, state, client, health)
         const saved = await state.load(repository.owner, repository.repo);
         if (saved.hookId !== undefined &&
             (await updateManagedHook(repository, endpoint, saved, client))) {
-            health.recordSuccess(scope, 'webhook');
             return;
         }
         const hookId = await client.createHook({
@@ -77,7 +87,6 @@ async function provisionRepository(repository, endpoint, state, client, health)
             events: [...events],
         });
         await state.save(repository.owner, repository.repo, { ...saved, hookId });
-        health.recordSuccess(scope, 'webhook');
     }
     catch (error) {
         health.recordFailure(scope, 'webhook', error);

package/dist/src/integrations/github/provider.d.ts

@@ -1,3 +1,3 @@
-import type { ProviderDefinition } from '../contracts/provider.js';
+import { type ProviderDefinition } from '../contracts/provider.js';
 import { type GitHubConfig } from './contracts/config.js';
 export declare const gitHubProviderDefinition: ProviderDefinition<GitHubConfig>;

package/dist/src/integrations/github/provider.js

@@ -2,6 +2,7 @@ import { BuiltInActivityName, PullRequestState } from '../../activities/index.js
 import { ConversationSurfaceCapability } from '../../orchestration/index.js';
 import { BuiltInResourceCapability, BuiltInResourceKind, ResourceCorrelationRole, resourceId, resourceKind, } from '../../resources/index.js';
 import { ArtifactVerificationResult } from '../contracts/artifact-vocabulary.js';
+import { AdapterHealthStatus } from '../contracts/provider.js';
 import { InboundTranslator } from './application/inbound-translator.js';
 import { translateGitHubOutbound } from './application/outbound-translator.js';
 import { createGitHubWakeLabelReconciler } from './application/wake-labels.js';
@@ -59,7 +60,15 @@ export const gitHubProviderDefinition = {
                 setLabels: client.setIssueLabels,
                 requests,
             }),
-            health: () => health.snapshotAll(),
+            health: () => health.snapshotAll().flatMap((check) => {
+                if (check.channel !== 'webhook')
+                    return [check];
+                if (!config.webhooks.enabled)
+                    return [];
+                return [
+                    check.successCount === 0 ? { ...check, status: AdapterHealthStatus.Unknown } : check,
+                ];
+            }),
             webhook: createGitHubWebhook(adapter, config, services.publicUiUrl, services.providerStateRoot, client, health),
             commands: () => [
                 ...Object.values(GitHubBuiltInCommand).map((syntax) => ({ syntax })),

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,