@exaudeus/workrail 3.43.0 → 3.45.0

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

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKRAIL_CONFIG_PATH = void 0;
+exports.loadQueueConfig = loadQueueConfig;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const result_js_1 = require("../runtime/result.js");
+exports.WORKRAIL_CONFIG_PATH = path.join(os.homedir(), '.workrail', 'config.json');
+async function loadQueueConfig(configPath = exports.WORKRAIL_CONFIG_PATH, env = process.env) {
+    let raw;
+    try {
+        raw = await fs.readFile(configPath, 'utf8');
+    }
+    catch (e) {
+        const error = e;
+        if (error.code === 'ENOENT') {
+            return (0, result_js_1.ok)(null);
+        }
+        return (0, result_js_1.err)(`Failed to read config file at ${configPath}: ${error.message ?? String(e)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        return (0, result_js_1.err)(`Failed to parse config JSON at ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        return (0, result_js_1.err)(`Config at ${configPath} is not a JSON object`);
+    }
+    const config = parsed;
+    if (!('queue' in config)) {
+        return (0, result_js_1.ok)(null);
+    }
+    const queue = config['queue'];
+    if (typeof queue !== 'object' || queue === null) {
+        return (0, result_js_1.err)('config.queue is not an object');
+    }
+    const q = queue;
+    const rawType = q['type'];
+    if (typeof rawType !== 'string') {
+        return (0, result_js_1.err)('config.queue.type is required and must be a string');
+    }
+    const VALID_TYPES = new Set(['assignee', 'label', 'mention', 'query']);
+    if (!VALID_TYPES.has(rawType)) {
+        return (0, result_js_1.err)(`config.queue.type must be one of: assignee, label, mention, query. Got: "${rawType}"`);
+    }
+    const rawRepo = q['repo'];
+    if (typeof rawRepo !== 'string' || !rawRepo.trim()) {
+        return (0, result_js_1.err)('config.queue.repo is required and must be a non-empty string');
+    }
+    const rawToken = q['token'];
+    if (typeof rawToken !== 'string' || !rawToken.trim()) {
+        return (0, result_js_1.err)('config.queue.token is required and must be a non-empty string');
+    }
+    let resolvedToken;
+    if (rawToken.startsWith('$')) {
+        const envVarName = rawToken.slice(1);
+        const envValue = env[envVarName];
+        if (!envValue) {
+            return (0, result_js_1.err)(`config.queue.token references env var $${envVarName} which is unset or empty`);
+        }
+        resolvedToken = envValue;
+    }
+    else {
+        resolvedToken = rawToken.trim();
+    }
+    const rawPollInterval = q['pollIntervalSeconds'];
+    let pollIntervalSeconds = 300;
+    if (rawPollInterval !== undefined) {
+        if (typeof rawPollInterval !== 'number' || !Number.isInteger(rawPollInterval) || rawPollInterval <= 0) {
+            return (0, result_js_1.err)('config.queue.pollIntervalSeconds must be a positive integer');
+        }
+        pollIntervalSeconds = rawPollInterval;
+    }
+    const rawMaxConcurrent = q['maxTotalConcurrentSessions'] ?? q['maxConcurrentSelf'];
+    let maxTotalConcurrentSessions = 1;
+    if (rawMaxConcurrent !== undefined) {
+        if (typeof rawMaxConcurrent !== 'number' || !Number.isInteger(rawMaxConcurrent) || rawMaxConcurrent <= 0) {
+            return (0, result_js_1.err)('config.queue.maxTotalConcurrentSessions must be a positive integer');
+        }
+        maxTotalConcurrentSessions = rawMaxConcurrent;
+    }
+    const rawExcludeLabels = q['excludeLabels'];
+    let excludeLabels = [];
+    if (rawExcludeLabels !== undefined) {
+        if (!Array.isArray(rawExcludeLabels) || !rawExcludeLabels.every(l => typeof l === 'string')) {
+            return (0, result_js_1.err)('config.queue.excludeLabels must be an array of strings');
+        }
+        excludeLabels = rawExcludeLabels;
+    }
+    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 rawHandle = q['handle'];
+    const handle = typeof rawHandle === 'string' && rawHandle.trim() ? rawHandle.trim() : undefined;
+    const rawSearch = q['search'];
+    const search = typeof rawSearch === 'string' && rawSearch.trim() ? rawSearch.trim() : undefined;
+    const rawWorkOnAll = q['workOnAll'];
+    const workOnAll = rawWorkOnAll === true;
+    const rawBotName = q['botName'];
+    const botName = typeof rawBotName === 'string' && rawBotName.trim() ? rawBotName.trim() : undefined;
+    const rawBotEmail = q['botEmail'];
+    const botEmail = typeof rawBotEmail === 'string' && rawBotEmail.trim() ? rawBotEmail.trim() : undefined;
+    return (0, result_js_1.ok)({
+        type: rawType,
+        ...(user !== undefined ? { user } : {}),
+        ...(labelName !== undefined ? { name: labelName } : {}),
+        ...(handle !== undefined ? { handle } : {}),
+        ...(search !== undefined ? { search } : {}),
+        ...(workOnAll ? { workOnAll } : {}),
+        pollIntervalSeconds,
+        maxTotalConcurrentSessions,
+        excludeLabels,
+        repo: rawRepo.trim(),
+        token: resolvedToken,
+        ...(botName !== undefined ? { botName } : {}),
+        ...(botEmail !== undefined ? { botEmail } : {}),
+    });
+}

package/dist/trigger/notification-service.d.ts

@@ -21,7 +21,7 @@ export interface NotificationConfig {
 export interface NotificationPayload {
     readonly event: 'session_completed';
     readonly workflowId: string;
-    readonly outcome: 'success' | 'error' | 'timeout' | 'delivery_failed';
+    readonly outcome: 'success' | 'error' | 'timeout' | 'stuck' | 'delivery_failed';
     readonly detail: string;
     readonly goal: string;
     readonly timestamp: string;

package/dist/trigger/notification-service.js

@@ -48,6 +48,8 @@ function buildNotificationBody(result, goal) {
             return `Session failed: ${truncated}`;
         case 'timeout':
             return `Session timed out: ${truncated}`;
+        case 'stuck':
+            return `Session stuck (${result.reason}): ${truncated}`;
         case 'delivery_failed':
             return `Session completed but result delivery failed: ${truncated}`;
     }
@@ -63,6 +65,8 @@ function buildDetail(result) {
             return result.message;
         case 'timeout':
             return result.message;
+        case 'stuck':
+            return result.message;
         case 'delivery_failed':
             return `stopReason: ${result.stopReason}; deliveryError: ${result.deliveryError}`;
     }

package/dist/trigger/polling-scheduler.d.ts

@@ -17,4 +17,5 @@ export declare class PollingScheduler {
     private doPollGitLab;
     private doPollGitHub;
     private dispatchAndRecord;
+    private doPollGitHubQueue;
 }

package/dist/trigger/polling-scheduler.js

@@ -1,8 +1,46 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PollingScheduler = void 0;
 const gitlab_poller_js_1 = require("./adapters/gitlab-poller.js");
 const github_poller_js_1 = require("./adapters/github-poller.js");
+const github_queue_poller_js_1 = require("./adapters/github-queue-poller.js");
+const github_queue_config_js_1 = require("./github-queue-config.js");
+const fs = __importStar(require("node:fs/promises"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
 function isPollingTrigger(trigger) {
     return trigger.pollingSource !== undefined;
 }
@@ -78,6 +116,9 @@ class PollingScheduler {
             case 'github_prs_poll':
                 await this.doPollGitHub(trigger, triggerId, pollStartAt, lastPollAt, trigger.pollingSource, 'prs');
                 break;
+            case 'github_queue_poll':
+                await this.doPollGitHubQueue(trigger, triggerId, trigger.pollingSource);
+                break;
             default: {
                 const _exhaustive = trigger.pollingSource;
                 console.warn(`[PollingScheduler] Unknown provider '${String(_exhaustive.provider)}' ` +
@@ -150,6 +191,111 @@ class PollingScheduler {
             console.log(`[PollingScheduler] Dispatched ${newIds.length} new event(s) for trigger '${triggerId}'`);
         }
     }
+    async doPollGitHubQueue(trigger, triggerId, source) {
+        const cycleStart = Date.now();
+        const configResult = await (0, github_queue_config_js_1.loadQueueConfig)();
+        if (configResult.kind === 'err') {
+            console.warn(`[QueuePoll] Failed to load queue config for trigger '${triggerId}': ${configResult.error}. Skipping cycle.`);
+            return;
+        }
+        const queueConfig = configResult.value;
+        if (queueConfig === null)
+            return;
+        if (queueConfig.type !== 'assignee') {
+            console.error(`[QueuePoll] Queue type '${queueConfig.type}' is not implemented. Only 'assignee' is supported. Skipping cycle.`);
+            await appendQueuePollLog({ event: 'poll_cycle_complete', triggerId, reason: 'not_implemented', queueType: queueConfig.type, ts: new Date().toISOString() });
+            return;
+        }
+        const sessionsDir = path.join(os.homedir(), '.workrail', 'daemon-sessions');
+        const activeSessions = await countActiveSessions(sessionsDir);
+        if (activeSessions >= queueConfig.maxTotalConcurrentSessions) {
+            console.log(`[QueuePoll] Skipping cycle: active sessions (${activeSessions}) >= maxTotalConcurrentSessions (${queueConfig.maxTotalConcurrentSessions}).`);
+            await appendQueuePollLog({ event: 'poll_cycle_skipped', triggerId, reason: 'max_concurrency_reached', activeSessions, maxTotalConcurrentSessions: queueConfig.maxTotalConcurrentSessions, ts: new Date().toISOString() });
+            return;
+        }
+        const fetchResult = await (0, github_queue_poller_js_1.pollGitHubQueueIssues)(source, queueConfig, this.fetchFn);
+        if (fetchResult.kind === 'err') {
+            console.warn(`[QueuePoll] GitHub API error for trigger '${triggerId}': ${fetchResult.error.kind}. Skipping cycle.`);
+            return;
+        }
+        const issues = fetchResult.value;
+        console.log(`[QueuePoll] cycle start repo=${source.repo} issues_fetched=${issues.length}`);
+        const candidates = [];
+        const skipped = [];
+        for (const issue of issues) {
+            const issueLabels = issue.labels.map((l) => l.name);
+            const excludedLabel = queueConfig.excludeLabels.find((el) => issueLabels.includes(el));
+            if (excludedLabel) {
+                skipped.push({ issue, reason: `excluded_label: ${excludedLabel}` });
+                continue;
+            }
+            if (issueLabels.includes('worktrain:in-progress')) {
+                skipped.push({ issue, reason: 'active_session_or_in_progress' });
+                continue;
+            }
+            if (/sess_[a-z0-9]+/.test(issue.body)) {
+                skipped.push({ issue, reason: 'active_session_or_in_progress' });
+                continue;
+            }
+            const idempotencyStatus = await (0, github_queue_poller_js_1.checkIdempotency)(issue.number, sessionsDir);
+            if (idempotencyStatus === 'active') {
+                skipped.push({ issue, reason: 'active_session' });
+                continue;
+            }
+            const maturity = (0, github_queue_poller_js_1.inferMaturity)(issue.body);
+            candidates.push({ issue, maturity });
+        }
+        const MATURITY_RANK = { ready: 0, specced: 1, idea: 2 };
+        candidates.sort((a, b) => {
+            const rankDiff = (MATURITY_RANK[a.maturity] ?? 2) - (MATURITY_RANK[b.maturity] ?? 2);
+            return rankDiff !== 0 ? rankDiff : a.issue.number - b.issue.number;
+        });
+        for (const { issue, reason } of skipped) {
+            console.log(`[QueuePoll] skipped #${issue.number} "${issue.title}" reason=${reason}`);
+            await appendQueuePollLog({ event: 'task_skipped', issueNumber: issue.number, title: issue.title, reason, ts: new Date().toISOString() });
+        }
+        if (candidates.length === 0) {
+            console.log('[QueuePoll] No actionable issues found in this poll cycle.');
+            await appendQueuePollLog({ event: 'poll_cycle_complete', selected: 0, skipped: skipped.length, elapsed: Date.now() - cycleStart, ts: new Date().toISOString() });
+            return;
+        }
+        const top = candidates[0];
+        const upstreamSpecUrl = extractUpstreamSpecUrl(top.issue.body);
+        const taskCandidate = {
+            issueNumber: top.issue.number,
+            title: top.issue.title,
+            body: top.issue.body,
+            url: top.issue.url,
+            inferredMaturity: top.maturity,
+            ...(upstreamSpecUrl !== undefined ? { upstreamSpecUrl } : {}),
+            queueConfigType: queueConfig.type,
+        };
+        const workflowTrigger = {
+            workflowId: trigger.workflowId,
+            goal: top.issue.title,
+            workspacePath: trigger.workspacePath,
+            context: { taskCandidate },
+            ...(trigger.referenceUrls !== undefined ? { referenceUrls: trigger.referenceUrls } : {}),
+            ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
+            ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
+            botIdentity: {
+                name: queueConfig.botName ?? 'worktrain',
+                email: queueConfig.botEmail ?? 'worktrain@users.noreply.github.com',
+            },
+        };
+        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);
+        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}`);
+            await appendQueuePollLog({ event: 'task_skipped', issueNumber: issue.number, title: issue.title, inferredMaturity: maturity, reason: `lower_priority_${maturity}`, ts: new Date().toISOString() });
+        }
+        const elapsed = Date.now() - cycleStart;
+        console.log(`[QueuePoll] cycle complete selected=1 skipped=${skipped.length + candidates.length - 1} elapsed=${elapsed}ms`);
+        await appendQueuePollLog({ event: 'poll_cycle_complete', selected: 1, skipped: skipped.length + candidates.length - 1, elapsed, ts: new Date().toISOString() });
+    }
 }
 exports.PollingScheduler = PollingScheduler;
 function buildGitLabWorkflowTrigger(trigger, mr) {
@@ -232,12 +378,12 @@ function interpolateGoalFromPayload(trigger, payload) {
     return template.replace(/\{\{([^}]+)\}\}/g, (_, token) => resolved.get(token) ?? trigger.goal);
 }
 function extractDotPath(obj, rawPath) {
-    let path = rawPath.trim();
-    if (path.startsWith('$.'))
-        path = path.slice(2);
-    else if (path.startsWith('$'))
-        path = path.slice(1);
-    const segments = path.split('.');
+    let dotPath = rawPath.trim();
+    if (dotPath.startsWith('$.'))
+        dotPath = dotPath.slice(2);
+    else if (dotPath.startsWith('$'))
+        dotPath = dotPath.slice(1);
+    const segments = dotPath.split('.');
     let current = obj;
     for (const segment of segments) {
         if (segment.includes('[') || current === null || typeof current !== 'object') {
@@ -247,3 +393,36 @@ function extractDotPath(obj, rawPath) {
     }
     return current;
 }
+async function countActiveSessions(sessionsDir) {
+    try {
+        const files = await fs.readdir(sessionsDir);
+        return files.filter((f) => f.endsWith('.json')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function appendQueuePollLog(entry) {
+    const logPath = path.join(os.homedir(), '.workrail', 'queue-poll.jsonl');
+    try {
+        await fs.appendFile(logPath, JSON.stringify(entry) + '\n', 'utf8');
+    }
+    catch (e) {
+        console.warn(`[QueuePoll] Failed to write queue-poll.jsonl: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function extractUpstreamSpecUrl(body) {
+    const specLineMatch = /upstream_spec:\s*(https?:\/\/\S+)/i.exec(body);
+    if (specLineMatch?.[1])
+        return specLineMatch[1];
+    const firstPara = body.split(/\n\s*\n/)[0] ?? '';
+    const urlMatch = /(https?:\/\/\S+)/.exec(firstPara);
+    return urlMatch?.[1];
+}
+function describeMaturityReason(maturity) {
+    switch (maturity) {
+        case 'ready': return 'has upstream spec URL';
+        case 'specced': return 'has acceptance criteria or checklist';
+        case 'idea': return 'maturity=idea, no upstream spec';
+    }
+}

package/dist/trigger/trigger-router.js

@@ -327,6 +327,10 @@ class TriggerRouter {
                 console.log(`[TriggerRouter] Workflow failed: triggerId=${trigger.id} ` +
                     `workflowId=${trigger.workflowId} error=${result.message} stopReason=${result.stopReason}`);
             }
+            else if (result._tag === 'stuck') {
+                console.log(`[TriggerRouter] Workflow stuck: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} reason=${result.reason} message=${result.message}`);
+            }
             else {
                 (0, assert_never_js_1.assertNever)(result);
             }
@@ -366,6 +370,10 @@ class TriggerRouter {
                 console.log(`[TriggerRouter] Dispatch failed: workflowId=${workflowTrigger.workflowId} ` +
                     `error=${result.message} stopReason=${result.stopReason}`);
             }
+            else if (result._tag === 'stuck') {
+                console.log(`[TriggerRouter] Dispatch stuck: workflowId=${workflowTrigger.workflowId} ` +
+                    `reason=${result.reason} message=${result.message}`);
+            }
             else {
                 (0, assert_never_js_1.assertNever)(result);
             }

package/dist/trigger/trigger-store.js

@@ -41,7 +41,7 @@ const path = __importStar(require("node:path"));
 const fs = __importStar(require("node:fs/promises"));
 const result_js_1 = require("../runtime/result.js");
 const types_js_1 = require("./types.js");
-const SUPPORTED_PROVIDERS = new Set(['generic', 'gitlab_poll', 'github_issues_poll', 'github_prs_poll']);
+const SUPPORTED_PROVIDERS = new Set(['generic', 'gitlab_poll', 'github_issues_poll', 'github_prs_poll', 'github_queue_poll']);
 function unquoteYamlScalar(raw) {
     const s = raw.trim();
     if ((s.startsWith('"') && s.endsWith('"')) ||
@@ -754,10 +754,43 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
             };
         }
     }
+    else if (provider === 'github_queue_poll') {
+        if (!raw.source) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source', triggerId: rawId });
+        }
+        const queueSrc = raw.source;
+        if (!queueSrc.repo?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.repo', triggerId: rawId });
+        }
+        if (!queueSrc.token?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.token', triggerId: rawId });
+        }
+        const queueTokenResult = resolveSecret(queueSrc.token.trim(), rawId, env);
+        if (queueTokenResult.kind === 'err')
+            return queueTokenResult;
+        let queuePollIntervalSeconds = 300;
+        if (queueSrc.pollIntervalSeconds?.trim()) {
+            const asNumber = Number(queueSrc.pollIntervalSeconds.trim());
+            if (!Number.isInteger(asNumber) || asNumber <= 0) {
+                return (0, result_js_1.err)({
+                    kind: 'invalid_field_value',
+                    field: `source.pollIntervalSeconds (must be a positive integer, got: ${queueSrc.pollIntervalSeconds})`,
+                    triggerId: rawId,
+                });
+            }
+            queuePollIntervalSeconds = asNumber;
+        }
+        pollingSource = {
+            provider: 'github_queue_poll',
+            repo: queueSrc.repo.trim(),
+            token: queueTokenResult.value,
+            pollIntervalSeconds: queuePollIntervalSeconds,
+        };
+    }
     else if (raw.source) {
         console.warn(`[TriggerStore] WARNING: trigger '${rawId}' has provider='${provider}' but also ` +
             `defines a source: block. The source: block is only used for polling providers ` +
-            `(gitlab_poll, github_issues_poll, github_prs_poll). It will be ignored for this trigger.`);
+            `(gitlab_poll, github_issues_poll, github_prs_poll, github_queue_poll). It will be ignored for this trigger.`);
     }
     const trigger = {
         id: (0, types_js_1.asTriggerId)(rawId),

package/dist/trigger/types.d.ts

@@ -34,12 +34,28 @@ export interface GitHubPollingSource {
     readonly notLabels: readonly string[];
     readonly labelFilter: readonly string[];
 }
+export interface GitHubQueuePollingSource {
+    readonly repo: string;
+    readonly token: string;
+    readonly pollIntervalSeconds: number;
+}
+export interface TaskCandidate {
+    readonly issueNumber: number;
+    readonly title: string;
+    readonly body: string;
+    readonly url: string;
+    readonly inferredMaturity: 'idea' | 'specced' | 'ready';
+    readonly upstreamSpecUrl?: string;
+    readonly queueConfigType: 'assignee' | 'label' | 'mention' | 'query';
+}
 export type PollingSource = (GitLabPollingSource & {
     readonly provider: 'gitlab_poll';
 }) | (GitHubPollingSource & {
     readonly provider: 'github_issues_poll';
 }) | (GitHubPollingSource & {
     readonly provider: 'github_prs_poll';
+}) | (GitHubQueuePollingSource & {
+    readonly provider: 'github_queue_poll';
 });
 export interface TriggerDefinition {
     readonly id: TriggerId;
@@ -55,6 +71,8 @@ export interface TriggerDefinition {
         readonly model?: string;
         readonly maxSessionMinutes?: number;
         readonly maxTurns?: number;
+        readonly stuckAbortPolicy?: 'abort' | 'notify_only';
+        readonly noProgressAbortEnabled?: boolean;
     };
     readonly concurrencyMode: 'serial' | 'parallel';
     readonly callbackUrl?: string;

package/dist/v2/usecases/console-routes.js

@@ -604,6 +604,9 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
                 else if (result._tag === 'error') {
                     console.log(`[ConsoleRoutes] Auto dispatch failed: workflowId=${workflowId} error=${result.message}`);
                 }
+                else if (result._tag === 'stuck') {
+                    console.log(`[ConsoleRoutes] Auto dispatch stuck: workflowId=${workflowId} reason=${result.reason} message=${result.message}`);
+                }
                 else {
                     (0, assert_never_js_1.assertNever)(result);
                 }