@exaudeus/workrail 3.46.0 → 3.47.0

package/dist/manifest.json

@@ -457,8 +457,8 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console-ui/assets/index-BQFhoMcY.js": {
-      "sha256": "722cfaf2b1b513c79b9f4d62cc79bd0f59c953c959480a8745efbdccf80df3d8",
+    "console-ui/assets/index-B77l3WBR.js": {
+      "sha256": "0c8b1d161e8b0cfc37d5b358b8753b3d6fa00e844bbca6ba56f7969afcc95606",
       "bytes": 760528
     },
     "console-ui/assets/index-DGj8EsFR.css": {
@@ -466,7 +466,7 @@
       "bytes": 60631
     },
     "console-ui/index.html": {
-      "sha256": "b4d9928edd90bb6778c3685eb511c9e7600937720b6212e018a017fbbbe7b8c5",
+      "sha256": "93463e0e8b5f6e0fd0e5b6c5807f4ac673abfa00f35b10dea9a3b7ea0792e178",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -526,12 +526,12 @@
       "bytes": 11782
     },
     "coordinators/modes/implement-shared.d.ts": {
-      "sha256": "64e3ba7e31bf9965b74645d7157a85fb67d9df183696a4d792cec870b22047e0",
-      "bytes": 554
+      "sha256": "fbad9d91d84d2112b273175618686489a7f106385e0e62d6cab80804d6d0f2d7",
+      "bytes": 708
     },
     "coordinators/modes/implement-shared.js": {
-      "sha256": "c39e7b1c088663a75f86b2dd81326940537c53408c7182a55f2b1288796cd002",
-      "bytes": 11023
+      "sha256": "a1727713839630d279377e9607b26068821a5a393bfbd42696222fb97ec4fe5f",
+      "bytes": 11400
     },
     "coordinators/modes/implement.d.ts": {
       "sha256": "23919c24d62a0bf15296a52fbc594cca8b1b34e6f8d98dcf7dede8d97ad4cabb",
@@ -1618,8 +1618,8 @@
       "bytes": 1363
     },
     "trigger/adapters/github-queue-poller.js": {
-      "sha256": "73270636634fb8673c63b0c0347e6e5d7f676606d36b87a4c1aadc11f1939eb2",
-      "bytes": 7340
+      "sha256": "ea6c402fe42dd3bac1b15e001d572d5e2a503f3ac0a3d3dac4175f80e603bb35",
+      "bytes": 7442
     },
     "trigger/adapters/gitlab-poller.d.ts": {
       "sha256": "f685490fafad77194fdd0f0bbaf80dbc56730aeb344853da365199a120fbe399",
@@ -1654,12 +1654,12 @@
       "bytes": 1269
     },
     "trigger/github-queue-config.d.ts": {
-      "sha256": "bff922c1b435da55e02b4b11d3fde9f06e999f13b8ac0494788cac4a4fc4c432",
-      "bytes": 766
+      "sha256": "4dd68c2b880f808aa67c3b6be1867299c0b49ce5cf7e39f4f093dbd341d1a1e8",
+      "bytes": 800
     },
     "trigger/github-queue-config.js": {
-      "sha256": "a0ec09a7725ac1ee1adb9d41fdcb4c9545128f0b9515c6de4df9535d4bec1acc",
-      "bytes": 6857
+      "sha256": "dd508fc3f9f58a70cdc076029154a3c1610569c611471e9b67bf1cd4be64a520",
+      "bytes": 7347
     },
     "trigger/index.d.ts": {
       "sha256": "a9cfd053714173e2a8cc5a282fd5b09a5c3f3001304d507facd0e12de9cc0733",
@@ -1690,36 +1690,36 @@
       "bytes": 792
     },
     "trigger/polling-scheduler.js": {
-      "sha256": "ec3c73739c9dfbbe3b2d7a55237fd35a290d6aab7bbc30ec5408bde69b2c95e0",
-      "bytes": 19769
+      "sha256": "dd5532f3dff75377685fb68d78820cb5916f823626b91d6306ad7aa3d9801be5",
+      "bytes": 20188
     },
     "trigger/trigger-listener.d.ts": {
       "sha256": "92e971ab8f47c3c867860cffc01f54c4aae54fcc4ae199b9469210f4ce639423",
       "bytes": 1639
     },
     "trigger/trigger-listener.js": {
-      "sha256": "347ce68b2b6d14be5277488e7d54ac0d9e80173407ee12dbb2f7df90765bac3c",
-      "bytes": 10668
+      "sha256": "1c73115b26d9274c86fd3b1e19f5eae2754d58e248949b6eaf0e7b7074b91c8c",
+      "bytes": 25421
     },
     "trigger/trigger-router.d.ts": {
-      "sha256": "b3154af4d32d6d71ae38fb6befc54850d137a12b2f602a34247b0c5f9b57a29d",
-      "bytes": 2519
+      "sha256": "44f1bfefafee4955bad74db9e61ecb6a49ea426c46100753f6bdb3a7f7b583dd",
+      "bytes": 2671
     },
     "trigger/trigger-router.js": {
-      "sha256": "682bf6e3a9d0fa5e25378c361813fdc52e5b828dff7267fd084d83f242585492",
-      "bytes": 18144
+      "sha256": "1f84935ad94e36be5befbef34d10deb7467c708e6d06cd36903843806f4b49a6",
+      "bytes": 19067
     },
     "trigger/trigger-store.d.ts": {
       "sha256": "7afb05127d55bc3757a550dd15d4b797766b3fff29d1bfe76b303764b93322e7",
       "bytes": 1588
     },
     "trigger/trigger-store.js": {
-      "sha256": "8015b54da7ab5b1cec78e1ecea099d5b457eaa5de267bb1ed52cbb75eca207c4",
-      "bytes": 38148
+      "sha256": "8e85e0bdbd1596e70c23667e84ed380d6f0cee10028cd1a41163cda3467c2bdc",
+      "bytes": 38559
     },
     "trigger/types.d.ts": {
-      "sha256": "a1336ad769dbe4760e7acd3b2a92961251492aa29245b5d906ad89011ea934fa",
-      "bytes": 3587
+      "sha256": "611f047631d8334a966acb7d1a71f5aa0d8cda65da127e07081b363290bcfdc2",
+      "bytes": 3654
     },
     "trigger/types.js": {
       "sha256": "45b4e4f23a6d1a2b07350196871b0c53840e5d8142b47f7acedd2f40ae7a6b73",
@@ -2262,12 +2262,12 @@
       "bytes": 2115
     },
     "v2/durable-core/schemas/artifacts/review-verdict.d.ts": {
-      "sha256": "3190c4c99a6f7fe85d56b4e2f16ee2239d5f8b1addf995b76359f231909cc3d3",
-      "bytes": 1562
+      "sha256": "2b9f7ae6b3fafe6c26f266bb249c8c286144eb1f753c803d4358ef81e30d1736",
+      "bytes": 2211
     },
     "v2/durable-core/schemas/artifacts/review-verdict.js": {
-      "sha256": "72915617cb08834e37a65c45b3eb84ff04c84d6e4a12c9e87be5a90a3d80cee5",
-      "bytes": 1206
+      "sha256": "67e03f956523b68783f0d01414bf04992070204d8bb828cdbb303bd0d914a220",
+      "bytes": 1557
     },
     "v2/durable-core/schemas/compiled-workflow/index.d.ts": {
       "sha256": "66e5a5e8d87e1c4743acfad71fa81c22775d377b566701d71c17227a4f4c969c",

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

@@ -36,11 +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, coordinatorDeps: AdaptiveCoordinatorDeps, modeExecutors: ModeExecutors, context?: Readonly<Record<string, unknown>>): ReturnType<typeof runAdaptivePipeline>;
+    dispatchAdaptivePipeline(goal: string, workspace: string, context?: Readonly<Record<string, unknown>>, coordinatorDeps?: AdaptiveCoordinatorDeps, modeExecutors?: ModeExecutors): ReturnType<typeof runAdaptivePipeline>;
 }

package/dist/trigger/trigger-router.js

@@ -204,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;
@@ -214,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) {
@@ -385,13 +387,27 @@ class TriggerRouter {
     listTriggers() {
         return [...this.index.values()];
     }
-    async dispatchAdaptivePipeline(goal, workspace, coordinatorDeps, modeExecutors, context) {
+    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)(coordinatorDeps, opts, modeExecutors);
+        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;