@exaudeus/workrail 3.45.0 → 3.47.0

package/dist/trigger/adapters/github-queue-poller.js

@@ -57,19 +57,22 @@ function checkRateLimit(response) {
     return false;
 }
 async function pollGitHubQueueIssues(source, config, fetchFn = globalThis.fetch) {
-    if (config.type !== 'assignee') {
-        return (0, result_js_1.err)({
-            kind: 'not_implemented',
-            message: `Queue type '${config.type}' is not implemented. Only 'assignee' is supported.`,
-        });
-    }
     const [owner, repo] = source.repo.split('/');
     const url = new URL(`https://api.github.com/repos/${owner}/${repo}/issues`);
     url.searchParams.set('state', 'open');
     url.searchParams.set('per_page', '100');
-    if (config.user) {
+    if (config.type === 'assignee' && config.user) {
         url.searchParams.set('assignee', config.user);
     }
+    else if (config.type === 'label' && config.queueLabel) {
+        url.searchParams.set('labels', config.queueLabel);
+    }
+    else {
+        return (0, result_js_1.err)({
+            kind: 'not_implemented',
+            message: `Queue type "${config.type}" is not yet implemented`,
+        });
+    }
     let response;
     try {
         response = await fetchFn(url.toString(), {

package/dist/trigger/github-queue-config.d.ts

@@ -2,6 +2,7 @@ import type { Result } from '../runtime/result.js';
 export interface GitHubQueueConfig {
     readonly type: 'assignee' | 'label' | 'mention' | 'query';
     readonly user?: string;
+    readonly queueLabel?: string;
     readonly name?: string;
     readonly handle?: string;
     readonly search?: string;

package/dist/trigger/github-queue-config.js

@@ -123,10 +123,18 @@ async function loadQueueConfig(configPath = exports.WORKRAIL_CONFIG_PATH, env =
         }
         excludeLabels = rawExcludeLabels;
     }
+    if (rawType === 'label') {
+        const rawQueueLabel = q['queueLabel'];
+        if (typeof rawQueueLabel !== 'string' || !rawQueueLabel.trim()) {
+            return (0, result_js_1.err)('config.queue.queueLabel is required when type is "label"');
+        }
+    }
     const rawUser = q['user'];
     const user = typeof rawUser === 'string' && rawUser.trim() ? rawUser.trim() : undefined;
     const rawName = q['name'];
     const labelName = typeof rawName === 'string' && rawName.trim() ? rawName.trim() : undefined;
+    const rawQueueLabel = q['queueLabel'];
+    const queueLabel = typeof rawQueueLabel === 'string' && rawQueueLabel.trim() ? rawQueueLabel.trim() : undefined;
     const rawHandle = q['handle'];
     const handle = typeof rawHandle === 'string' && rawHandle.trim() ? rawHandle.trim() : undefined;
     const rawSearch = q['search'];
@@ -140,6 +148,7 @@ async function loadQueueConfig(configPath = exports.WORKRAIL_CONFIG_PATH, env =
     return (0, result_js_1.ok)({
         type: rawType,
         ...(user !== undefined ? { user } : {}),
+        ...(queueLabel !== undefined ? { queueLabel } : {}),
         ...(labelName !== undefined ? { name: labelName } : {}),
         ...(handle !== undefined ? { handle } : {}),
         ...(search !== undefined ? { search } : {}),

package/dist/trigger/polling-scheduler.js

@@ -286,7 +286,14 @@ class PollingScheduler {
         const maturityReason = describeMaturityReason(top.maturity);
         console.log(`[QueuePoll] selected #${top.issue.number} "${top.issue.title}" maturity=${top.maturity} reason="${maturityReason}"`);
         await appendQueuePollLog({ event: 'task_selected', issueNumber: top.issue.number, title: top.issue.title, maturity: top.maturity, reason: maturityReason, ts: new Date().toISOString() });
-        this.router.dispatch(workflowTrigger);
+        if ('dispatchAdaptivePipeline' in this.router &&
+            typeof this.router.dispatchAdaptivePipeline === 'function') {
+            void this.router.dispatchAdaptivePipeline(workflowTrigger.goal, workflowTrigger.workspacePath, workflowTrigger.context);
+            console.log(`[QueuePoll] dispatched via adaptivePipeline goal="${workflowTrigger.goal.slice(0, 80)}"`);
+        }
+        else {
+            this.router.dispatch(workflowTrigger);
+        }
         for (let i = 1; i < candidates.length; i++) {
             const { issue, maturity } = candidates[i];
             console.log(`[QueuePoll] skipped #${issue.number} "${issue.title}" reason=lower_priority_${maturity}`);

package/dist/trigger/trigger-listener.js

@@ -41,6 +41,12 @@ exports.startTriggerListener = startTriggerListener;
 require("reflect-metadata");
 const express_1 = __importDefault(require("express"));
 const http = __importStar(require("node:http"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_crypto_1 = require("node:crypto");
 const trigger_store_js_1 = require("./trigger-store.js");
 const trigger_router_js_1 = require("./trigger-router.js");
 const config_file_js_1 = require("../config/config-file.js");
@@ -49,6 +55,12 @@ const workflow_runner_js_1 = require("../daemon/workflow-runner.js");
 const types_js_1 = require("./types.js");
 const polling_scheduler_js_1 = require("./polling-scheduler.js");
 const polled_event_store_js_1 = require("./polled-event-store.js");
+const index_js_1 = require("../context-assembly/index.js");
+const infra_js_1 = require("../context-assembly/infra.js");
+const quick_review_js_1 = require("../coordinators/modes/quick-review.js");
+const review_only_js_1 = require("../coordinators/modes/review-only.js");
+const implement_js_1 = require("../coordinators/modes/implement.js");
+const full_pipeline_js_1 = require("../coordinators/modes/full-pipeline.js");
 const DEFAULT_TRIGGER_PORT = 3200;
 function createTriggerApp(router) {
     const app = (0, express_1.default)();
@@ -184,8 +196,291 @@ async function startTriggerListener(ctx, options) {
         ? new notification_service_js_1.NotificationService({ macOs: notifyMacOs, webhookUrl: notifyWebhook })
         : undefined;
     const steerRegistry = new Map();
+    const DAEMON_CONSOLE_PORT = 3456;
+    const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+    const coordinatorDeps = {
+        spawnSession: async (workflowId, goal, workspace, context) => {
+            const url = `http://127.0.0.1:${DAEMON_CONSOLE_PORT}/api/v2/auto/dispatch`;
+            try {
+                const response = await globalThis.fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workflowId,
+                        goal,
+                        workspacePath: workspace,
+                        ...(context !== undefined ? { context } : {}),
+                    }),
+                    signal: AbortSignal.timeout(30000),
+                });
+                const body = await response.json();
+                if (!response.ok) {
+                    const errMsg = typeof body['error'] === 'string' ? body['error'] : `HTTP ${response.status}`;
+                    if (response.status === 503) {
+                        return { kind: 'err', error: `WorkTrain daemon is not ready: ${errMsg}` };
+                    }
+                    return { kind: 'err', error: `Dispatch failed: ${errMsg}` };
+                }
+                if (body['success'] !== true || typeof body['data'] !== 'object') {
+                    return { kind: 'err', error: 'Unexpected response from dispatch endpoint' };
+                }
+                const data = body['data'];
+                const handle = typeof data['sessionHandle'] === 'string' ? data['sessionHandle'] : '';
+                if (!handle) {
+                    return { kind: 'err', error: 'Dispatch succeeded but no session handle returned' };
+                }
+                return { kind: 'ok', value: handle };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                const isConnRefused = msg.includes('ECONNREFUSED') || msg.includes('fetch failed');
+                if (isConnRefused) {
+                    return { kind: 'err', error: `Could not connect to WorkTrain daemon on port ${DAEMON_CONSOLE_PORT}. Ensure the daemon is running.` };
+                }
+                if (e instanceof Error && e.name === 'TimeoutError') {
+                    return { kind: 'err', error: `Daemon request timed out after 30s` };
+                }
+                return { kind: 'err', error: `Dispatch request failed: ${msg}` };
+            }
+        },
+        contextAssembler: (0, index_js_1.createContextAssembler)({
+            execGit: async (args, cwd) => {
+                try {
+                    const { stdout } = await execFileAsync('git', [...args], { cwd });
+                    return { kind: 'ok', value: stdout };
+                }
+                catch (e) {
+                    return { kind: 'err', error: e instanceof Error ? e.message : String(e) };
+                }
+            },
+            execGh: async (args, cwd) => {
+                try {
+                    const { stdout } = await execFileAsync('gh', [...args], { cwd });
+                    return { kind: 'ok', value: stdout };
+                }
+                catch (e) {
+                    return { kind: 'err', error: e instanceof Error ? e.message : String(e) };
+                }
+            },
+            listRecentSessions: (0, infra_js_1.createListRecentSessions)(),
+            nowIso: () => new Date().toISOString(),
+        }),
+        awaitSessions: async (handles, timeoutMs) => {
+            const { executeWorktrainAwaitCommand } = await Promise.resolve().then(() => __importStar(require('../cli/commands/worktrain-await.js')));
+            let resolvedResult = null;
+            await executeWorktrainAwaitCommand({
+                fetch: (url) => globalThis.fetch(url),
+                readFile: (p) => fs.promises.readFile(p, 'utf-8'),
+                stdout: (line) => {
+                    try {
+                        resolvedResult = JSON.parse(line);
+                    }
+                    catch { }
+                },
+                stderr: (line) => process.stderr.write(line + '\n'),
+                homedir: os.homedir,
+                joinPath: path.join,
+                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+                now: () => Date.now(),
+            }, {
+                sessions: [...handles].join(','),
+                mode: 'all',
+                timeout: `${Math.round(timeoutMs / 1000)}s`,
+                port: DAEMON_CONSOLE_PORT,
+            });
+            if (resolvedResult === null) {
+                process.stderr.write(`[WARN coord:reason=await_failed] awaitSessions: could not get session results -- daemon may be unreachable or timed out. Returning all ${handles.length} session(s) as failed.\n`);
+            }
+            return resolvedResult ?? {
+                results: [...handles].map((h) => ({
+                    handle: h,
+                    outcome: 'failed',
+                    status: null,
+                    durationMs: 0,
+                })),
+                allSucceeded: false,
+            };
+        },
+        getAgentResult: async (sessionHandle) => {
+            const emptyResult = { recapMarkdown: null, artifacts: [] };
+            try {
+                const sessionUrl = `http://127.0.0.1:${DAEMON_CONSOLE_PORT}/api/v2/sessions/${encodeURIComponent(sessionHandle)}`;
+                const sessionRes = await globalThis.fetch(sessionUrl, { signal: AbortSignal.timeout(30000) });
+                if (!sessionRes.ok) {
+                    process.stderr.write(`[WARN coord:reason=http_error status=${sessionRes.status} handle=${sessionHandle.slice(0, 16)}] getAgentResult: session fetch returned HTTP ${sessionRes.status}\n`);
+                    return emptyResult;
+                }
+                const sessionBody = await sessionRes.json();
+                if (sessionBody['success'] !== true) {
+                    return emptyResult;
+                }
+                const data = sessionBody['data'];
+                if (!data)
+                    return emptyResult;
+                const runs = data['runs'];
+                if (!Array.isArray(runs) || runs.length === 0)
+                    return emptyResult;
+                const firstRun = runs[0];
+                const tipNodeId = typeof firstRun['preferredTipNodeId'] === 'string'
+                    ? firstRun['preferredTipNodeId']
+                    : null;
+                if (!tipNodeId)
+                    return emptyResult;
+                const allNodes = Array.isArray(firstRun['nodes'])
+                    ? firstRun['nodes']
+                    : [];
+                const allNodeIds = allNodes
+                    .map((n) => (typeof n['nodeId'] === 'string' ? n['nodeId'] : null))
+                    .filter((id) => id !== null);
+                const nodeIdsToFetch = allNodeIds.length > 0 ? allNodeIds : [tipNodeId];
+                const baseNodeUrl = `http://127.0.0.1:${DAEMON_CONSOLE_PORT}/api/v2/sessions/${encodeURIComponent(sessionHandle)}/nodes/`;
+                let recap = null;
+                const collectedArtifacts = [];
+                for (const nodeId of nodeIdsToFetch) {
+                    try {
+                        const nodeRes = await globalThis.fetch(baseNodeUrl + encodeURIComponent(nodeId), { signal: AbortSignal.timeout(30000) });
+                        if (!nodeRes.ok)
+                            continue;
+                        const nodeBody = await nodeRes.json();
+                        if (nodeBody['success'] !== true)
+                            continue;
+                        const nodeData = nodeBody['data'];
+                        if (!nodeData)
+                            continue;
+                        if (nodeId === tipNodeId) {
+                            recap = typeof nodeData['recapMarkdown'] === 'string' ? nodeData['recapMarkdown'] : null;
+                        }
+                        const nodeArtifacts = nodeData['artifacts'];
+                        if (Array.isArray(nodeArtifacts) && nodeArtifacts.length > 0) {
+                            collectedArtifacts.push(...nodeArtifacts);
+                        }
+                    }
+                    catch (nodeErr) {
+                        const msg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
+                        process.stderr.write(`[WARN coord:reason=node_exception handle=${sessionHandle.slice(0, 16)} node=${nodeId.slice(0, 16)}] getAgentResult: ${msg}\n`);
+                    }
+                }
+                return { recapMarkdown: recap, artifacts: collectedArtifacts };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                process.stderr.write(`[WARN coord:reason=exception handle=${sessionHandle.slice(0, 16)}] getAgentResult: ${msg}\n`);
+                return emptyResult;
+            }
+        },
+        listOpenPRs: async (workspace) => {
+            try {
+                const { stdout } = await execFileAsync('gh', ['pr', 'list', '--json', 'number,title,headRefName'], {
+                    cwd: workspace,
+                    timeout: 30000,
+                });
+                const parsed = JSON.parse(stdout);
+                return parsed.map((p) => ({ number: p.number, title: p.title, headRef: p.headRefName }));
+            }
+            catch {
+                return [];
+            }
+        },
+        mergePR: async (prNumber, workspace) => {
+            try {
+                await execFileAsync('gh', ['pr', 'merge', String(prNumber), '--squash', '--auto'], {
+                    cwd: workspace,
+                    timeout: 60000,
+                });
+                return { kind: 'ok', value: undefined };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { kind: 'err', error: msg };
+            }
+        },
+        writeFile: async (filePath, content) => {
+            await fs.promises.writeFile(filePath, content, 'utf-8');
+        },
+        readFile: (filePath) => fs.promises.readFile(filePath, 'utf-8'),
+        appendFile: (filePath, content) => fs.promises.appendFile(filePath, content, 'utf-8'),
+        mkdir: (dirPath, opts) => fs.promises.mkdir(dirPath, opts),
+        homedir: os.homedir,
+        joinPath: path.join,
+        nowIso: () => new Date().toISOString(),
+        generateId: () => (0, node_crypto_1.randomUUID)(),
+        stderr: (line) => process.stderr.write(line + '\n'),
+        now: () => Date.now(),
+        port: DAEMON_CONSOLE_PORT,
+        fileExists: (p) => fs.existsSync(p),
+        archiveFile: (src, dest) => fs.promises.rename(src, dest),
+        pollForPR: async (branchPattern, timeoutMs) => {
+            const pollIntervalMs = 30000;
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                try {
+                    const { stdout } = await execFileAsync('gh', ['pr', 'list', '--head', branchPattern, '--json', 'url', '--limit', '1'], { timeout: 30000 });
+                    const parsed = JSON.parse(stdout);
+                    if (parsed.length > 0 && parsed[0] && parsed[0].url) {
+                        return parsed[0].url;
+                    }
+                }
+                catch {
+                }
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+            }
+            return null;
+        },
+        postToOutbox: async (message, metadata) => {
+            const workrailDir = path.join(os.homedir(), '.workrail');
+            const outboxPath = path.join(workrailDir, 'outbox.jsonl');
+            await fs.promises.mkdir(workrailDir, { recursive: true });
+            const entry = JSON.stringify({
+                id: (0, node_crypto_1.randomUUID)(),
+                message,
+                metadata,
+                timestamp: new Date().toISOString(),
+            });
+            await fs.promises.appendFile(outboxPath, entry + '\n', 'utf-8');
+        },
+        pollOutboxAck: async (requestId, timeoutMs) => {
+            const pollIntervalMs = 5 * 60 * 1000;
+            const workrailDir = path.join(os.homedir(), '.workrail');
+            const outboxPath = path.join(workrailDir, 'outbox.jsonl');
+            const cursorPath = path.join(workrailDir, 'inbox-cursor.json');
+            let snapshotCount = 0;
+            try {
+                const outboxContent = await fs.promises.readFile(outboxPath, 'utf-8');
+                snapshotCount = outboxContent.split('\n').filter((l) => l.trim() !== '').length;
+            }
+            catch {
+            }
+            void requestId;
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+                try {
+                    const cursorContent = await fs.promises.readFile(cursorPath, 'utf-8');
+                    const cursor = JSON.parse(cursorContent);
+                    if (typeof cursor.lastReadCount === 'number' && cursor.lastReadCount > snapshotCount) {
+                        return 'acked';
+                    }
+                }
+                catch {
+                }
+            }
+            return 'timeout';
+        },
+    };
+    const modeExecutors = {
+        runQuickReview: quick_review_js_1.runQuickReviewPipeline,
+        runReviewOnly: review_only_js_1.runReviewOnlyPipeline,
+        runImplement: implement_js_1.runImplementPipeline,
+        runFull: full_pipeline_js_1.runFullPipeline,
+    };
     const runWorkflowFn = options.runWorkflowFn ?? workflow_runner_js_1.runWorkflow;
-    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions, options.emitter, notificationService, steerRegistry);
+    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions, options.emitter, notificationService, steerRegistry, coordinatorDeps, modeExecutors);
     const app = createTriggerApp(router);
     const allTriggers = [...triggerIndex.values()];
     const polledEventStore = new polled_event_store_js_1.PolledEventStore(env);

package/dist/trigger/trigger-router.d.ts

@@ -4,6 +4,8 @@ import type { TriggerDefinition, WebhookEvent } from './types.js';
 import type { ExecFn } from './delivery-action.js';
 import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
 import type { NotificationService } from './notification-service.js';
+import type { AdaptiveCoordinatorDeps, ModeExecutors } from '../coordinators/adaptive-pipeline.js';
+import { runAdaptivePipeline } from '../coordinators/adaptive-pipeline.js';
 export type RouteError = {
     readonly kind: 'not_found';
     readonly triggerId: string;
@@ -34,10 +36,13 @@ export declare class TriggerRouter {
     private readonly emitter;
     private readonly notificationService;
     private readonly steerRegistry;
-    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number, emitter?: DaemonEventEmitter, notificationService?: NotificationService, steerRegistry?: SteerRegistry);
+    private readonly _coordinatorDeps;
+    private readonly _modeExecutors;
+    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number, emitter?: DaemonEventEmitter, notificationService?: NotificationService, steerRegistry?: SteerRegistry, coordinatorDeps?: AdaptiveCoordinatorDeps, modeExecutors?: ModeExecutors);
     get activeSessions(): number;
     get maxConcurrentSessions(): number;
     route(event: WebhookEvent): RouteResult;
     dispatch(workflowTrigger: WorkflowTrigger): string;
     listTriggers(): readonly TriggerDefinition[];
+    dispatchAdaptivePipeline(goal: string, workspace: string, context?: Readonly<Record<string, unknown>>, coordinatorDeps?: AdaptiveCoordinatorDeps, modeExecutors?: ModeExecutors): ReturnType<typeof runAdaptivePipeline>;
 }

package/dist/trigger/trigger-router.js

@@ -42,6 +42,7 @@ const assert_never_js_1 = require("../runtime/assert-never.js");
 const index_js_1 = require("../v2/infra/in-memory/keyed-async-queue/index.js");
 const delivery_client_js_1 = require("./delivery-client.js");
 const delivery_action_js_1 = require("./delivery-action.js");
+const adaptive_pipeline_js_1 = require("../coordinators/adaptive-pipeline.js");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 function interpolateGoalTemplate(template, staticGoal, payload, triggerId) {
     const TOKEN_RE = /\{\{([^}]+)\}\}/g;
@@ -203,7 +204,7 @@ class Semaphore {
 }
 const DEFAULT_MAX_CONCURRENT_SESSIONS = 3;
 class TriggerRouter {
-    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions, emitter, notificationService, steerRegistry) {
+    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions, emitter, notificationService, steerRegistry, coordinatorDeps, modeExecutors) {
         this.index = index;
         this.ctx = ctx;
         this.apiKey = apiKey;
@@ -213,6 +214,8 @@ class TriggerRouter {
         this.emitter = emitter;
         this.notificationService = notificationService;
         this.steerRegistry = steerRegistry;
+        this._coordinatorDeps = coordinatorDeps;
+        this._modeExecutors = modeExecutors;
         const requested = maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
         const cap = Number.isNaN(requested) ? DEFAULT_MAX_CONCURRENT_SESSIONS : requested;
         if (cap < 1) {
@@ -384,5 +387,27 @@ class TriggerRouter {
     listTriggers() {
         return [...this.index.values()];
     }
+    async dispatchAdaptivePipeline(goal, workspace, context, coordinatorDeps, modeExecutors) {
+        const effectiveDeps = coordinatorDeps ?? this._coordinatorDeps;
+        const effectiveExecutors = modeExecutors ?? this._modeExecutors;
+        if (effectiveDeps === undefined || effectiveExecutors === undefined) {
+            console.warn('[TriggerRouter] dispatchAdaptivePipeline called but coordinatorDeps not injected -- ' +
+                'adaptive dispatch disabled. Inject coordinatorDeps and modeExecutors in the ' +
+                'TriggerRouter constructor to activate. Returning escalated outcome.');
+            return {
+                kind: 'escalated',
+                escalationReason: {
+                    phase: 'dispatch',
+                    reason: 'coordinatorDeps or modeExecutors not injected into TriggerRouter',
+                },
+            };
+        }
+        const opts = {
+            goal,
+            workspace,
+            taskCandidate: context,
+        };
+        return (0, adaptive_pipeline_js_1.runAdaptivePipeline)(effectiveDeps, opts, effectiveExecutors);
+    }
 }
 exports.TriggerRouter = TriggerRouter;

package/dist/trigger/trigger-store.js

@@ -400,6 +400,12 @@ function setTriggerField(trigger, key, value) {
         case 'branchPrefix':
             trigger.branchPrefix = value;
             break;
+        case 'queueType':
+            trigger.queueType = value;
+            break;
+        case 'queueLabel':
+            trigger.queueLabel = value;
+            break;
         default:
             break;
     }
@@ -780,11 +786,15 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
             }
             queuePollIntervalSeconds = asNumber;
         }
+        const rawQueueType = raw.queueType?.trim();
+        const rawQueueLabel = raw.queueLabel?.trim();
         pollingSource = {
             provider: 'github_queue_poll',
             repo: queueSrc.repo.trim(),
             token: queueTokenResult.value,
             pollIntervalSeconds: queuePollIntervalSeconds,
+            ...(rawQueueType ? { queueType: rawQueueType } : {}),
+            ...(rawQueueLabel ? { queueLabel: rawQueueLabel } : {}),
         };
     }
     else if (raw.source) {

package/dist/trigger/types.d.ts

@@ -38,6 +38,8 @@ export interface GitHubQueuePollingSource {
     readonly repo: string;
     readonly token: string;
     readonly pollIntervalSeconds: number;
+    readonly queueType?: string;
+    readonly queueLabel?: string;
 }
 export interface TaskCandidate {
     readonly issueNumber: number;

package/dist/v2/durable-core/schemas/artifacts/discovery-handoff.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const DISCOVERY_HANDOFF_CONTRACT_REF: "wr.contracts.discovery_handoff";
+export declare const DiscoveryHandoffArtifactV1Schema: z.ZodObject<{
+    kind: z.ZodLiteral<"wr.discovery_handoff">;
+    version: z.ZodLiteral<1>;
+    selectedDirection: z.ZodString;
+    designDocPath: z.ZodString;
+    confidenceBand: z.ZodEnum<["high", "medium", "low"]>;
+    keyInvariants: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    kind: "wr.discovery_handoff";
+    version: 1;
+    selectedDirection: string;
+    designDocPath: string;
+    confidenceBand: "low" | "high" | "medium";
+    keyInvariants: string[];
+}, {
+    kind: "wr.discovery_handoff";
+    version: 1;
+    selectedDirection: string;
+    designDocPath: string;
+    confidenceBand: "low" | "high" | "medium";
+    keyInvariants: string[];
+}>;
+export type DiscoveryHandoffArtifactV1 = z.infer<typeof DiscoveryHandoffArtifactV1Schema>;
+export declare function isDiscoveryHandoffArtifact(artifact: unknown): artifact is {
+    readonly kind: 'wr.discovery_handoff';
+};
+export declare function parseDiscoveryHandoffArtifact(artifact: unknown): DiscoveryHandoffArtifactV1 | null;

package/dist/v2/durable-core/schemas/artifacts/discovery-handoff.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryHandoffArtifactV1Schema = exports.DISCOVERY_HANDOFF_CONTRACT_REF = void 0;
+exports.isDiscoveryHandoffArtifact = isDiscoveryHandoffArtifact;
+exports.parseDiscoveryHandoffArtifact = parseDiscoveryHandoffArtifact;
+const zod_1 = require("zod");
+exports.DISCOVERY_HANDOFF_CONTRACT_REF = 'wr.contracts.discovery_handoff';
+exports.DiscoveryHandoffArtifactV1Schema = zod_1.z
+    .object({
+    kind: zod_1.z.literal('wr.discovery_handoff'),
+    version: zod_1.z.literal(1),
+    selectedDirection: zod_1.z.string().min(1),
+    designDocPath: zod_1.z.string(),
+    confidenceBand: zod_1.z.enum(['high', 'medium', 'low']),
+    keyInvariants: zod_1.z.array(zod_1.z.string().min(1)),
+})
+    .strict();
+function isDiscoveryHandoffArtifact(artifact) {
+    return (typeof artifact === 'object' &&
+        artifact !== null &&
+        artifact.kind === 'wr.discovery_handoff');
+}
+function parseDiscoveryHandoffArtifact(artifact) {
+    const result = exports.DiscoveryHandoffArtifactV1Schema.safeParse(artifact);
+    return result.success ? result.data : null;
+}

package/dist/v2/durable-core/schemas/artifacts/index.d.ts

@@ -2,6 +2,7 @@ export { ASSESSMENT_CONTRACT_REF, AssessmentArtifactV1Schema, AssessmentDimensio
 export { LOOP_CONTROL_CONTRACT_REF, LoopControlDecisionSchema, LoopControlMetadataV1Schema, LoopControlArtifactV1Schema, isLoopControlArtifact, parseLoopControlArtifact, findLoopControlArtifact, type LoopControlDecision, type LoopControlMetadataV1, type LoopControlArtifactV1, } from './loop-control.js';
 export { COORDINATOR_SIGNAL_CONTRACT_REF, CoordinatorSignalKindSchema, CoordinatorSignalArtifactV1Schema, isCoordinatorSignalArtifact, parseCoordinatorSignalArtifact, type CoordinatorSignalKind, type CoordinatorSignalArtifactV1, } from './coordinator-signal.js';
 export { REVIEW_VERDICT_CONTRACT_REF, ReviewVerdictArtifactV1Schema, isReviewVerdictArtifact, parseReviewVerdictArtifact, type ReviewVerdictArtifactV1, } from './review-verdict.js';
-export declare const ARTIFACT_CONTRACT_REFS: readonly ["wr.contracts.assessment", "wr.contracts.loop_control", "wr.contracts.coordinator_signal", "wr.contracts.review_verdict"];
+export { DISCOVERY_HANDOFF_CONTRACT_REF, DiscoveryHandoffArtifactV1Schema, isDiscoveryHandoffArtifact, parseDiscoveryHandoffArtifact, type DiscoveryHandoffArtifactV1, } from './discovery-handoff.js';
+export declare const ARTIFACT_CONTRACT_REFS: readonly ["wr.contracts.assessment", "wr.contracts.loop_control", "wr.contracts.coordinator_signal", "wr.contracts.review_verdict", "wr.contracts.discovery_handoff"];
 export type ArtifactContractRef = (typeof ARTIFACT_CONTRACT_REFS)[number];
 export declare function isValidContractRef(ref: string): ref is ArtifactContractRef;

package/dist/v2/durable-core/schemas/artifacts/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ARTIFACT_CONTRACT_REFS = exports.parseReviewVerdictArtifact = exports.isReviewVerdictArtifact = exports.ReviewVerdictArtifactV1Schema = exports.REVIEW_VERDICT_CONTRACT_REF = exports.parseCoordinatorSignalArtifact = exports.isCoordinatorSignalArtifact = exports.CoordinatorSignalArtifactV1Schema = exports.CoordinatorSignalKindSchema = exports.COORDINATOR_SIGNAL_CONTRACT_REF = exports.findLoopControlArtifact = exports.parseLoopControlArtifact = exports.isLoopControlArtifact = exports.LoopControlArtifactV1Schema = exports.LoopControlMetadataV1Schema = exports.LoopControlDecisionSchema = exports.LOOP_CONTROL_CONTRACT_REF = exports.parseAssessmentArtifact = exports.isAssessmentArtifact = exports.AssessmentDimensionSubmissionSchema = exports.AssessmentArtifactV1Schema = exports.ASSESSMENT_CONTRACT_REF = void 0;
+exports.ARTIFACT_CONTRACT_REFS = exports.parseDiscoveryHandoffArtifact = exports.isDiscoveryHandoffArtifact = exports.DiscoveryHandoffArtifactV1Schema = exports.DISCOVERY_HANDOFF_CONTRACT_REF = exports.parseReviewVerdictArtifact = exports.isReviewVerdictArtifact = exports.ReviewVerdictArtifactV1Schema = exports.REVIEW_VERDICT_CONTRACT_REF = exports.parseCoordinatorSignalArtifact = exports.isCoordinatorSignalArtifact = exports.CoordinatorSignalArtifactV1Schema = exports.CoordinatorSignalKindSchema = exports.COORDINATOR_SIGNAL_CONTRACT_REF = exports.findLoopControlArtifact = exports.parseLoopControlArtifact = exports.isLoopControlArtifact = exports.LoopControlArtifactV1Schema = exports.LoopControlMetadataV1Schema = exports.LoopControlDecisionSchema = exports.LOOP_CONTROL_CONTRACT_REF = exports.parseAssessmentArtifact = exports.isAssessmentArtifact = exports.AssessmentDimensionSubmissionSchema = exports.AssessmentArtifactV1Schema = exports.ASSESSMENT_CONTRACT_REF = void 0;
 exports.isValidContractRef = isValidContractRef;
 var assessment_js_1 = require("./assessment.js");
 Object.defineProperty(exports, "ASSESSMENT_CONTRACT_REF", { enumerable: true, get: function () { return assessment_js_1.ASSESSMENT_CONTRACT_REF; } });
@@ -27,11 +27,17 @@ Object.defineProperty(exports, "REVIEW_VERDICT_CONTRACT_REF", { enumerable: true
 Object.defineProperty(exports, "ReviewVerdictArtifactV1Schema", { enumerable: true, get: function () { return review_verdict_js_1.ReviewVerdictArtifactV1Schema; } });
 Object.defineProperty(exports, "isReviewVerdictArtifact", { enumerable: true, get: function () { return review_verdict_js_1.isReviewVerdictArtifact; } });
 Object.defineProperty(exports, "parseReviewVerdictArtifact", { enumerable: true, get: function () { return review_verdict_js_1.parseReviewVerdictArtifact; } });
+var discovery_handoff_js_1 = require("./discovery-handoff.js");
+Object.defineProperty(exports, "DISCOVERY_HANDOFF_CONTRACT_REF", { enumerable: true, get: function () { return discovery_handoff_js_1.DISCOVERY_HANDOFF_CONTRACT_REF; } });
+Object.defineProperty(exports, "DiscoveryHandoffArtifactV1Schema", { enumerable: true, get: function () { return discovery_handoff_js_1.DiscoveryHandoffArtifactV1Schema; } });
+Object.defineProperty(exports, "isDiscoveryHandoffArtifact", { enumerable: true, get: function () { return discovery_handoff_js_1.isDiscoveryHandoffArtifact; } });
+Object.defineProperty(exports, "parseDiscoveryHandoffArtifact", { enumerable: true, get: function () { return discovery_handoff_js_1.parseDiscoveryHandoffArtifact; } });
 exports.ARTIFACT_CONTRACT_REFS = [
     'wr.contracts.assessment',
     'wr.contracts.loop_control',
     'wr.contracts.coordinator_signal',
     'wr.contracts.review_verdict',
+    'wr.contracts.discovery_handoff',
 ];
 function isValidContractRef(ref) {
     return exports.ARTIFACT_CONTRACT_REFS.includes(ref);

package/dist/v2/durable-core/schemas/artifacts/review-verdict.d.ts

@@ -7,12 +7,15 @@ export declare const ReviewVerdictArtifactV1Schema: z.ZodObject<{
     findings: z.ZodArray<z.ZodObject<{
         severity: z.ZodEnum<["critical", "major", "minor", "nit"]>;
         summary: z.ZodString;
+        findingCategory: z.ZodOptional<z.ZodEnum<["correctness", "security", "architecture", "ux", "performance", "testing", "style"]>>;
     }, "strict", z.ZodTypeAny, {
         severity: "critical" | "minor" | "major" | "nit";
         summary: string;
+        findingCategory?: "correctness" | "security" | "architecture" | "ux" | "performance" | "testing" | "style" | undefined;
     }, {
         severity: "critical" | "minor" | "major" | "nit";
         summary: string;
+        findingCategory?: "correctness" | "security" | "architecture" | "ux" | "performance" | "testing" | "style" | undefined;
     }>, "many">;
     summary: z.ZodString;
 }, "strict", z.ZodTypeAny, {
@@ -23,6 +26,7 @@ export declare const ReviewVerdictArtifactV1Schema: z.ZodObject<{
     findings: {
         severity: "critical" | "minor" | "major" | "nit";
         summary: string;
+        findingCategory?: "correctness" | "security" | "architecture" | "ux" | "performance" | "testing" | "style" | undefined;
     }[];
 }, {
     kind: "wr.review_verdict";
@@ -32,6 +36,7 @@ export declare const ReviewVerdictArtifactV1Schema: z.ZodObject<{
     findings: {
         severity: "critical" | "minor" | "major" | "nit";
         summary: string;
+        findingCategory?: "correctness" | "security" | "architecture" | "ux" | "performance" | "testing" | "style" | undefined;
     }[];
 }>;
 export type ReviewVerdictArtifactV1 = z.infer<typeof ReviewVerdictArtifactV1Schema>;