@exaudeus/workrail 3.42.0 → 3.44.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/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

@@ -136,7 +136,17 @@ async function maybeRunDelivery(triggerId, trigger, result, execFn) {
             `Ensure the workflow's final step produces a JSON block with commitType, filesChanged, etc.`);
         return;
     }
-    const deliveryResult = await (0, delivery_action_js_1.runDelivery)(parseResult.value, trigger.workspacePath, { autoCommit: trigger.autoCommit, autoOpenPR: trigger.autoOpenPR }, execFn);
+    const deliveryCwd = result.sessionWorkspacePath ?? trigger.workspacePath;
+    const deliveryResult = await (0, delivery_action_js_1.runDelivery)(parseResult.value, deliveryCwd, {
+        autoCommit: trigger.autoCommit,
+        autoOpenPR: trigger.autoOpenPR,
+        ...(trigger.branchStrategy === 'worktree' && result.sessionWorkspacePath
+            ? {
+                sessionId: result.sessionId ?? '',
+                branchPrefix: trigger.branchPrefix ?? 'worktrain/',
+            }
+            : {}),
+    }, execFn);
     switch (deliveryResult._tag) {
         case 'committed':
             console.log(`[TriggerRouter] Delivery committed: triggerId=${triggerId} sha=${deliveryResult.sha}`);
@@ -152,6 +162,16 @@ async function maybeRunDelivery(triggerId, trigger, result, execFn) {
                 `details=${deliveryResult.details}`);
             break;
     }
+    if (trigger.branchStrategy === 'worktree' && result.sessionWorkspacePath) {
+        try {
+            await execFn('git', ['-C', trigger.workspacePath, 'worktree', 'remove', '--force', result.sessionWorkspacePath], { cwd: trigger.workspacePath, timeout: 60000 });
+            console.log(`[TriggerRouter] Worktree removed: triggerId=${triggerId} path=${result.sessionWorkspacePath}`);
+        }
+        catch (err) {
+            console.warn(`[TriggerRouter] Could not remove worktree: triggerId=${triggerId} ` +
+                `path=${result.sessionWorkspacePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
 }
 class Semaphore {
     constructor(max) {
@@ -246,6 +266,9 @@ class TriggerRouter {
             ...(trigger.referenceUrls !== undefined ? { referenceUrls: trigger.referenceUrls } : {}),
             ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
             ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
+            ...(trigger.branchStrategy !== undefined ? { branchStrategy: trigger.branchStrategy } : {}),
+            ...(trigger.baseBranch !== undefined ? { baseBranch: trigger.baseBranch } : {}),
+            ...(trigger.branchPrefix !== undefined ? { branchPrefix: trigger.branchPrefix } : {}),
         };
         this.emitter?.emit({ kind: 'trigger_fired', triggerId: trigger.id, workflowId: trigger.workflowId });
         const queueKey = trigger.concurrencyMode === 'parallel'

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('"')) ||
@@ -391,6 +391,15 @@ function setTriggerField(trigger, key, value) {
         case 'soulFile':
             trigger.soulFile = value;
             break;
+        case 'branchStrategy':
+            trigger.branchStrategy = value;
+            break;
+        case 'baseBranch':
+            trigger.baseBranch = value;
+            break;
+        case 'branchPrefix':
+            trigger.branchPrefix = value;
+            break;
         default:
             break;
     }
@@ -602,6 +611,36 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
         console.warn(`[TriggerStore] Warning: trigger "${rawId}" has autoOpenPR: true but autoCommit is not true. ` +
             `A PR requires a commit -- delivery will be skipped unless autoCommit is also set to true.`);
     }
+    const rawBranchStrategy = raw.branchStrategy?.trim();
+    if (rawBranchStrategy !== undefined && rawBranchStrategy !== 'worktree' && rawBranchStrategy !== 'none') {
+        return (0, result_js_1.err)({
+            kind: 'invalid_field_value',
+            field: `branchStrategy (must be "worktree" or "none", got: "${rawBranchStrategy}")`,
+            triggerId: rawId,
+        });
+    }
+    const branchStrategy = rawBranchStrategy === 'worktree' ? 'worktree' : rawBranchStrategy === 'none' ? 'none' : undefined;
+    const baseBranch = raw.baseBranch?.trim() || undefined;
+    const branchPrefix = raw.branchPrefix?.trim() || undefined;
+    const GIT_SAFE_RE = /^[a-zA-Z0-9._/-]+$/;
+    if (baseBranch !== undefined) {
+        if (!GIT_SAFE_RE.test(baseBranch) || baseBranch.startsWith('-')) {
+            return (0, result_js_1.err)({
+                kind: 'invalid_field_value',
+                field: `baseBranch (must match /^[a-zA-Z0-9._/-]+$/ and not start with "-", got: "${baseBranch}")`,
+                triggerId: rawId,
+            });
+        }
+    }
+    if (branchPrefix !== undefined) {
+        if (!GIT_SAFE_RE.test(branchPrefix) || branchPrefix.startsWith('-')) {
+            return (0, result_js_1.err)({
+                kind: 'invalid_field_value',
+                field: `branchPrefix (must match /^[a-zA-Z0-9._/-]+$/ and not start with "-", got: "${branchPrefix}")`,
+                triggerId: rawId,
+            });
+        }
+    }
     function parsePollIntervalSeconds(raw2, triggerId2) {
         const intervalRaw = raw2.pollIntervalSeconds?.trim();
         if (!intervalRaw)
@@ -715,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),
@@ -741,6 +813,9 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
         ...(pollingSource !== undefined ? { pollingSource } : {}),
         ...(resolvedWorkspaceName !== undefined ? { workspaceName: resolvedWorkspaceName } : {}),
         ...(resolvedSoulFile ? { soulFile: resolvedSoulFile } : {}),
+        ...(branchStrategy !== undefined ? { branchStrategy } : {}),
+        ...(baseBranch !== undefined ? { baseBranch } : {}),
+        ...(branchPrefix !== undefined ? { branchPrefix } : {}),
     };
     return (0, result_js_1.ok)(trigger);
 }

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;
@@ -68,6 +84,9 @@ export interface TriggerDefinition {
     readonly pollingSource?: PollingSource;
     readonly workspaceName?: WorkspaceName;
     readonly soulFile?: string;
+    readonly branchStrategy?: 'worktree' | 'none';
+    readonly baseBranch?: string;
+    readonly branchPrefix?: string;
 }
 export interface TriggerConfig {
     readonly triggers: readonly TriggerDefinition[];