@exaudeus/workrail 3.72.0 → 3.72.1

package/dist/trigger/delivery-pipeline.js

@@ -0,0 +1,148 @@
+"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.DEFAULT_DELIVERY_PIPELINE = void 0;
+exports.runDeliveryPipeline = runDeliveryPipeline;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const workflow_runner_js_1 = require("../daemon/workflow-runner.js");
+const delivery_action_js_1 = require("./delivery-action.js");
+async function runDeliveryPipeline(stages, result, trigger, execFn, triggerId) {
+    const ctx = {};
+    try {
+        for (const stage of stages) {
+            const outcome = await stage.run(result, trigger, execFn, ctx);
+            if (outcome.kind === 'stop') {
+                console.log(`[DeliveryPipeline] Stage "${stage.name}" stopped pipeline: triggerId=${triggerId} reason=${outcome.reason}`);
+                return;
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[DeliveryPipeline] Unexpected error in pipeline: triggerId=${triggerId} ` +
+            `error=${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+const parseHandoffStage = {
+    name: 'parseHandoff',
+    async run(result, trigger, _execFn, ctx) {
+        const parseResult = (0, delivery_action_js_1.parseHandoffArtifact)(result.lastStepNotes);
+        if (parseResult.kind === 'err') {
+            console.warn(`[DeliveryPipeline] Delivery skipped: triggerId=${trigger.id} -- ` +
+                `handoff artifact not parseable: ${parseResult.error}. ` +
+                `Ensure the workflow's final step produces a JSON block with commitType, filesChanged, etc.`);
+            return { kind: 'stop', reason: `handoff artifact parse failed: ${parseResult.error}` };
+        }
+        ctx.handoffArtifact = parseResult.value;
+        return { kind: 'continue' };
+    },
+};
+const gitDeliveryStage = {
+    name: 'gitDelivery',
+    async run(result, trigger, execFn, ctx) {
+        if (ctx.handoffArtifact === undefined) {
+            return {
+                kind: 'stop',
+                reason: 'handoffArtifact not available -- parseHandoffStage must run before gitDeliveryStage',
+            };
+        }
+        const deliveryCwd = result.sessionWorkspacePath ?? trigger.workspacePath;
+        const deliveryResult = await (0, delivery_action_js_1.runDelivery)(ctx.handoffArtifact, deliveryCwd, {
+            autoCommit: trigger.autoCommit,
+            autoOpenPR: trigger.autoOpenPR,
+            secretScan: trigger.secretScan ?? true,
+            triggerId: trigger.id,
+            workflowId: trigger.workflowId,
+            ...(result.botIdentity !== undefined ? { botIdentity: result.botIdentity } : {}),
+            ...(trigger.branchStrategy === 'worktree' && result.sessionWorkspacePath
+                ? {
+                    sessionId: result.sessionId ?? '',
+                    branchPrefix: trigger.branchPrefix ?? 'worktrain/',
+                }
+                : {}),
+        }, execFn);
+        switch (deliveryResult._tag) {
+            case 'committed':
+                console.log(`[DeliveryPipeline] Delivery committed: triggerId=${trigger.id} sha=${deliveryResult.sha}`);
+                break;
+            case 'pr_opened':
+                console.log(`[DeliveryPipeline] Delivery PR opened: triggerId=${trigger.id} url=${deliveryResult.url}`);
+                break;
+            case 'skipped':
+                console.log(`[DeliveryPipeline] Delivery skipped: triggerId=${trigger.id} reason=${deliveryResult.reason}`);
+                break;
+            case 'error':
+                console.warn(`[DeliveryPipeline] Delivery error: triggerId=${trigger.id} phase=${deliveryResult.phase} ` +
+                    `details=${deliveryResult.details}`);
+                break;
+        }
+        return { kind: 'continue' };
+    },
+};
+const cleanupWorktreeStage = {
+    name: 'cleanupWorktree',
+    async run(result, trigger, execFn, _ctx) {
+        if (trigger.branchStrategy !== 'worktree' || !result.sessionWorkspacePath) {
+            return { kind: 'continue' };
+        }
+        try {
+            await execFn('git', ['-C', trigger.workspacePath, 'worktree', 'remove', '--force', result.sessionWorkspacePath], { cwd: trigger.workspacePath, timeout: 60000 });
+            console.log(`[DeliveryPipeline] Worktree removed: triggerId=${trigger.id} path=${result.sessionWorkspacePath}`);
+        }
+        catch (err) {
+            console.warn(`[DeliveryPipeline] Could not remove worktree: triggerId=${trigger.id} ` +
+                `path=${result.sessionWorkspacePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { kind: 'continue' };
+    },
+};
+const deleteSidecarStage = {
+    name: 'deleteSidecar',
+    async run(result, trigger, _execFn, _ctx) {
+        if (trigger.branchStrategy !== 'worktree' || result.sessionId === undefined) {
+            return { kind: 'continue' };
+        }
+        await fs.unlink(path.join(workflow_runner_js_1.DAEMON_SESSIONS_DIR, `${result.sessionId}.json`)).catch(() => { });
+        await fs.unlink(path.join(workflow_runner_js_1.DAEMON_SESSIONS_DIR, `${result.sessionId}-conversation.jsonl`)).catch(() => { });
+        console.log(`[DeliveryPipeline] Session sidecar removed: triggerId=${trigger.id} sessionId=${result.sessionId}`);
+        return { kind: 'continue' };
+    },
+};
+exports.DEFAULT_DELIVERY_PIPELINE = [
+    parseHandoffStage,
+    gitDeliveryStage,
+    cleanupWorktreeStage,
+    deleteSidecarStage,
+];

package/dist/trigger/dispatch-deduplicator.d.ts

@@ -0,0 +1,6 @@
+export declare class DispatchDeduplicator {
+    private readonly _recent;
+    private readonly _ttlMs;
+    constructor(ttlMs: number);
+    checkAndRecord(key: string): boolean;
+}

package/dist/trigger/dispatch-deduplicator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DispatchDeduplicator = void 0;
+class DispatchDeduplicator {
+    constructor(ttlMs) {
+        this._recent = new Map();
+        this._ttlMs = ttlMs;
+    }
+    checkAndRecord(key) {
+        const now = Date.now();
+        for (const [k, ts] of this._recent) {
+            if (now - ts >= this._ttlMs) {
+                this._recent.delete(k);
+            }
+        }
+        const lastDispatch = this._recent.get(key);
+        if (lastDispatch !== undefined && now - lastDispatch < this._ttlMs) {
+            return true;
+        }
+        this._recent.set(key, now);
+        return false;
+    }
+}
+exports.DispatchDeduplicator = DispatchDeduplicator;

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

@@ -3,7 +3,7 @@ import express from 'express';
 import type { V2ToolContext } from '../mcp/types.js';
 import type { TriggerStoreError } from './trigger-store.js';
 import { TriggerRouter, type RunWorkflowFn } from './trigger-router.js';
-import type { SteerRegistry, AbortRegistry } from '../daemon/workflow-runner.js';
+import { ActiveSessionSet } from '../daemon/active-sessions.js';
 import type { WorkspaceConfig } from './types.js';
 import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
 import { PollingScheduler } from './polling-scheduler.js';
@@ -19,8 +19,7 @@ export type TriggerListenerError = TriggerStoreError | {
 export interface TriggerListenerHandle {
     readonly port: number;
     readonly router: TriggerRouter;
-    readonly steerRegistry: SteerRegistry;
-    readonly abortRegistry: AbortRegistry;
+    readonly activeSessionSet: ActiveSessionSet;
     readonly scheduler: PollingScheduler;
     stop(): Promise<void>;
 }

package/dist/trigger/trigger-listener.js

@@ -41,28 +41,22 @@ 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 active_sessions_js_1 = require("../daemon/active-sessions.js");
 const config_file_js_1 = require("../config/config-file.js");
 const notification_service_js_1 = require("./notification-service.js");
 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 start_js_1 = require("../mcp/handlers/v2-execution/start.js");
-const v2_token_ops_js_1 = require("../mcp/handlers/v2-token-ops.js");
+const coordinator_deps_js_1 = require("./coordinator-deps.js");
 const DEFAULT_TRIGGER_PORT = 3200;
 function createTriggerApp(router) {
     const app = (0, express_1.default)();
@@ -134,9 +128,8 @@ async function startTriggerListener(ctx, options) {
     if (env['WORKRAIL_TRIGGERS_ENABLED'] !== 'true') {
         return null;
     }
-    const apiKey = options.apiKey ?? env['ANTHROPIC_API_KEY'] ?? '';
-    const hasBedrock = !!(env['AWS_PROFILE'] || env['AWS_ACCESS_KEY_ID']);
-    if (!apiKey && !hasBedrock) {
+    const apiKey = options.apiKey ?? env['ANTHROPIC_API_KEY'];
+    if (!apiKey) {
         return { _kind: 'err', error: { kind: 'missing_api_key' } };
     }
     const workspaceResult = (0, config_file_js_1.loadWorkspacesFromConfigFile)();
@@ -210,8 +203,7 @@ async function startTriggerListener(ctx, options) {
     const notificationService = (notifyMacOs || (notifyWebhook !== undefined && notifyWebhook !== ''))
         ? new notification_service_js_1.NotificationService({ macOs: notifyMacOs, webhookUrl: notifyWebhook })
         : undefined;
-    const steerRegistry = new Map();
-    const abortRegistry = new Map();
+    const activeSessionSet = new active_sessions_js_1.ActiveSessionSet();
     const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
     const { ConsoleService } = await Promise.resolve().then(() => __importStar(require('../v2/usecases/console-service.js')));
     let consoleService = null;
@@ -227,265 +219,7 @@ async function startTriggerListener(ctx, options) {
             pinnedWorkflowStore: ctx.v2.pinnedStore,
         });
     }
-    let routerRef;
-    const coordinatorDeps = {
-        spawnSession: async (workflowId, goal, workspace, context, agentConfig) => {
-            if (routerRef === undefined) {
-                return { kind: 'err', error: 'in-process router not initialized -- coordinator deps not ready' };
-            }
-            const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId, workspacePath: workspace, goal }, ctx, { is_autonomous: 'true', workspacePath: workspace });
-            if (startResult.isErr()) {
-                const detail = `${startResult.error.kind}${'message' in startResult.error ? ': ' + startResult.error.message : ''}`;
-                return { kind: 'err', error: `Session creation failed: ${detail}` };
-            }
-            const startContinueToken = startResult.value.response.continueToken;
-            if (!startContinueToken) {
-                return { kind: 'ok', value: workflowId };
-            }
-            const tokenResult = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(startContinueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
-            if (tokenResult.isErr()) {
-                process.stderr.write(`[ERROR trigger-listener:spawnSession] Failed to decode session handle from new session: ${tokenResult.error.message}\n`);
-                return { kind: 'err', error: 'Internal error: could not extract session handle from new session' };
-            }
-            const sessionHandle = tokenResult.value.sessionId;
-            routerRef.dispatch({
-                workflowId,
-                goal,
-                workspacePath: workspace,
-                context,
-                ...(agentConfig !== undefined ? { agentConfig } : {}),
-                _preAllocatedStartResponse: startResult.value.response,
-            });
-            return { kind: 'ok', value: sessionHandle };
-        },
-        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 POLL_INTERVAL_MS = 3000;
-            if (consoleService === null) {
-                process.stderr.write(`[WARN coord:reason=await_degraded] awaitSessions: ConsoleService unavailable -- returning all ${handles.length} session(s) as failed.\n`);
-                return {
-                    results: [...handles].map((h) => ({
-                        handle: h,
-                        outcome: 'failed',
-                        status: null,
-                        durationMs: 0,
-                    })),
-                    allSucceeded: false,
-                };
-            }
-            const startMs = Date.now();
-            const pending = new Set(handles);
-            const results = new Map();
-            while (pending.size > 0) {
-                const elapsed = Date.now() - startMs;
-                if (elapsed >= timeoutMs) {
-                    break;
-                }
-                for (const handle of [...pending]) {
-                    try {
-                        const detail = await consoleService.getSessionDetail(handle);
-                        if (detail.isErr()) {
-                            continue;
-                        }
-                        const run = detail.value.runs[0];
-                        if (!run)
-                            continue;
-                        const status = run.status;
-                        if (status === 'complete' || status === 'complete_with_gaps') {
-                            results.set(handle, { handle, outcome: 'success', status, durationMs: Date.now() - startMs });
-                            pending.delete(handle);
-                        }
-                        else if (status === 'blocked') {
-                            results.set(handle, { handle, outcome: 'failed', status, durationMs: Date.now() - startMs });
-                            pending.delete(handle);
-                        }
-                    }
-                    catch {
-                        results.set(handle, { handle, outcome: 'failed', status: null, durationMs: Date.now() - startMs });
-                        pending.delete(handle);
-                    }
-                }
-                if (pending.size > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-                }
-            }
-            for (const handle of pending) {
-                results.set(handle, { handle, outcome: 'timeout', status: null, durationMs: timeoutMs });
-            }
-            const resultsArray = [...results.values()];
-            return {
-                results: resultsArray,
-                allSucceeded: resultsArray.every((r) => r.outcome === 'success'),
-            };
-        },
-        getAgentResult: async (sessionHandle) => {
-            const emptyResult = { recapMarkdown: null, artifacts: [] };
-            if (consoleService === null) {
-                return emptyResult;
-            }
-            try {
-                const detailResult = await consoleService.getSessionDetail(sessionHandle);
-                if (detailResult.isErr())
-                    return emptyResult;
-                const run = detailResult.value.runs[0];
-                if (!run)
-                    return emptyResult;
-                const tipNodeId = run.preferredTipNodeId;
-                if (!tipNodeId)
-                    return emptyResult;
-                const allNodeIds = run.nodes.map((n) => n.nodeId).filter((id) => typeof id === 'string' && id !== '');
-                const nodeIdsToFetch = allNodeIds.length > 0 ? allNodeIds : [tipNodeId];
-                let recap = null;
-                const collectedArtifacts = [];
-                for (const nodeId of nodeIdsToFetch) {
-                    try {
-                        const nodeResult = await consoleService.getNodeDetail(sessionHandle, nodeId);
-                        if (nodeResult.isErr())
-                            continue;
-                        if (nodeId === tipNodeId) {
-                            recap = nodeResult.value.recapMarkdown;
-                        }
-                        if (nodeResult.value.artifacts.length > 0) {
-                            collectedArtifacts.push(...nodeResult.value.artifacts);
-                        }
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-                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(),
-        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 coordinatorDeps = (0, coordinator_deps_js_1.createCoordinatorDeps)({ ctx, execFileAsync, consoleService });
     const modeExecutors = {
         runQuickReview: quick_review_js_1.runQuickReviewPipeline,
         runReviewOnly: review_only_js_1.runReviewOnlyPipeline,
@@ -493,8 +227,8 @@ async function startTriggerListener(ctx, options) {
         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, abortRegistry, coordinatorDeps, modeExecutors);
-    routerRef = router;
+    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions, options.emitter, notificationService, activeSessionSet, coordinatorDeps, modeExecutors);
+    coordinatorDeps.setDispatch(router.dispatch.bind(router));
     const app = createTriggerApp(router);
     const allTriggers = [...triggerIndex.values()];
     const polledEventStore = new polled_event_store_js_1.PolledEventStore(env);
@@ -529,8 +263,7 @@ async function startTriggerListener(ctx, options) {
             resolve({
                 port: actualPort,
                 router,
-                steerRegistry,
-                abortRegistry,
+                activeSessionSet,
                 scheduler: pollingScheduler,
                 stop: async () => {
                     pollingScheduler.stop();

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

@@ -1,4 +1,5 @@
-import type { WorkflowTrigger, WorkflowRunResult, SteerRegistry, AbortRegistry } from '../daemon/workflow-runner.js';
+import type { WorkflowTrigger, WorkflowRunResult, SessionSource } from '../daemon/workflow-runner.js';
+import type { ActiveSessionSet } from '../daemon/active-sessions.js';
 import type { V2ToolContext } from '../mcp/types.js';
 import type { TriggerDefinition, WebhookEvent } from './types.js';
 import type { ExecFn } from './delivery-action.js';
@@ -6,6 +7,7 @@ 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';
+import { DispatchDeduplicator } from './dispatch-deduplicator.js';
 export type RouteError = {
     readonly kind: 'not_found';
     readonly triggerId: string;
@@ -28,7 +30,7 @@ export type RouteResult = {
     readonly _tag: 'error';
     readonly error: RouteError;
 };
-export type RunWorkflowFn = (trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: import('../v2/infra/in-memory/daemon-registry/index.js').DaemonRegistry, emitter?: DaemonEventEmitter, steerRegistry?: SteerRegistry, abortRegistry?: AbortRegistry) => Promise<WorkflowRunResult>;
+export type RunWorkflowFn = (trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: import('../v2/infra/in-memory/daemon-registry/index.js').DaemonRegistry, emitter?: DaemonEventEmitter, activeSessionSet?: ActiveSessionSet, _statsDir?: string, _sessionsDir?: string, source?: SessionSource) => Promise<WorkflowRunResult>;
 export declare function interpolateGoalTemplate(template: string, staticGoal: string, payload: Readonly<Record<string, unknown>>, triggerId: string): string;
 export declare class TriggerRouter {
     private readonly index;
@@ -41,17 +43,16 @@ export declare class TriggerRouter {
     private readonly _maxConcurrentSessions;
     private readonly emitter;
     private readonly notificationService;
-    private readonly steerRegistry;
-    private readonly abortRegistry;
+    private readonly _activeSessionSet;
     private readonly _coordinatorDeps;
     private readonly _modeExecutors;
-    private readonly _recentAdaptiveDispatches;
+    private readonly _deduplicator;
     private static readonly ADAPTIVE_DEDUPE_TTL_MS;
-    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number, emitter?: DaemonEventEmitter, notificationService?: NotificationService, steerRegistry?: SteerRegistry, abortRegistry?: AbortRegistry, coordinatorDeps?: AdaptiveCoordinatorDeps, modeExecutors?: ModeExecutors);
+    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number, emitter?: DaemonEventEmitter, notificationService?: NotificationService, activeSessionSet?: ActiveSessionSet, coordinatorDeps?: AdaptiveCoordinatorDeps, modeExecutors?: ModeExecutors, deduplicator?: DispatchDeduplicator);
     get activeSessions(): number;
     get maxConcurrentSessions(): number;
     route(event: WebhookEvent): RouteResult;
-    dispatch(workflowTrigger: WorkflowTrigger): string;
+    dispatch(workflowTrigger: WorkflowTrigger, source?: SessionSource): string;
     listTriggers(): readonly TriggerDefinition[];
     dispatchAdaptivePipeline(goal: string, workspace: string, context?: Readonly<Record<string, unknown>>, coordinatorDeps?: AdaptiveCoordinatorDeps, modeExecutors?: ModeExecutors): ReturnType<typeof runAdaptivePipeline>;
 }