@exaudeus/workrail 3.59.4 → 3.59.6

package/dist/manifest.json

@@ -481,16 +481,16 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console-ui/assets/index-BuMfiLrV.js": {
-      "sha256": "e7d0e3f4ded8e370e8c34846ffce1404d28d0eb2613bf89b10cfc22a678ea6cf",
-      "bytes": 760528
-    },
     "console-ui/assets/index-DGj8EsFR.css": {
       "sha256": "3bdb55ec0957928e0ebbb86a7d6b36d28f7ba7d5c0f3e236fd8f2e2aacee2fa4",
       "bytes": 60631
     },
+    "console-ui/assets/index-xMwhHmR2.js": {
+      "sha256": "9fbff5f59a5e014930778fd79a1de39f532b20862a4fa10d7320d12602b445fc",
+      "bytes": 760528
+    },
     "console-ui/index.html": {
-      "sha256": "314e6af46d83e7e0daa7a3efb2a998ac981f7f2ff58bae090ddcbd26b477c855",
+      "sha256": "1aa1ca8a09fba68cb675918108702a338ec426ec0a6778736dbd1842e8a1a8bc",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -546,8 +546,8 @@
       "bytes": 462
     },
     "coordinators/modes/full-pipeline.js": {
-      "sha256": "a03cf485201d23b0ddf75ca36ea10741bb9d0373479e7df3350401653229ef8b",
-      "bytes": 12850
+      "sha256": "945d726d728235f8f31f03f33fbde8f6614472b38921a44fba42da959875f37d",
+      "bytes": 13201
     },
     "coordinators/modes/implement-shared.d.ts": {
       "sha256": "fbad9d91d84d2112b273175618686489a7f106385e0e62d6cab80804d6d0f2d7",
@@ -582,8 +582,8 @@
       "bytes": 1198
     },
     "coordinators/pr-review.d.ts": {
-      "sha256": "a8886a3c83a31e869522812d1342a301e9bfae92d8e5e694594c3c50912035d9",
-      "bytes": 3833
+      "sha256": "d46e4923995a0b43aefee25da298b86235fae0ad105e548b3174c0eea9c1f8d0",
+      "bytes": 3947
     },
     "coordinators/pr-review.js": {
       "sha256": "84b51f931eb55d908de8c60f90b4d4b66540054791a28ce2f07426a841fed386",
@@ -1650,8 +1650,8 @@
       "bytes": 1363
     },
     "trigger/adapters/github-queue-poller.js": {
-      "sha256": "c1a4866ff7ead5b33439da2ff7842747e119bf411e8057b1a08d580816689dd1",
-      "bytes": 7935
+      "sha256": "b15f56cf0782a1eceb66ef6d58bb75b17e14f701f1e95d072fe7a71b5aa6a4f5",
+      "bytes": 8824
     },
     "trigger/adapters/gitlab-poller.d.ts": {
       "sha256": "f685490fafad77194fdd0f0bbaf80dbc56730aeb344853da365199a120fbe399",
@@ -1718,28 +1718,28 @@
       "bytes": 6968
     },
     "trigger/polling-scheduler.d.ts": {
-      "sha256": "60df456a31fa87ce71de76f5e31a6c460bfab588a24c8a2f06bf926fdcea550a",
-      "bytes": 1096
+      "sha256": "3c0865f9d21819c364575062745741405bc80006f4a0754d26ed4302253371c6",
+      "bytes": 1126
     },
     "trigger/polling-scheduler.js": {
-      "sha256": "ef1252ee4bc4592fc416e7a00aa4e7db297035a990231941ae9316cdf5fe5b9a",
-      "bytes": 21667
+      "sha256": "0588534bacec382e00eb766d33438569f31563e5bbad8d3498ef64c00a0f87db",
+      "bytes": 23912
     },
     "trigger/trigger-listener.d.ts": {
       "sha256": "1eebb3d4829030b264c3798b0b0d55d7357d313ab83e3f344ad455eaafcedb44",
       "bytes": 1740
     },
     "trigger/trigger-listener.js": {
-      "sha256": "09b8bbcda1825a9314dc29ac7435ef703fb0cdad13fa54ffe45f68767f22fbc7",
-      "bytes": 25095
+      "sha256": "4aa62601aac5d3c7d1750ef839ee71a911dacbab346fb6dfdb3d7151e9e7d359",
+      "bytes": 25179
     },
     "trigger/trigger-router.d.ts": {
       "sha256": "b916f33cab64d491ab04bd13dd37599d33e687f7aea1e69e50f5fcea4b3b4624",
       "bytes": 2771
     },
     "trigger/trigger-router.js": {
-      "sha256": "b4b7da7c897f7f296fc0fd00d4cffb335a1d5949ea39b8dffa4ab64e3b91589d",
-      "bytes": 22634
+      "sha256": "efd9fe3990ea51cd896dfbb8a854e5509cd4adc1221bb96d0f96a128dc7df676",
+      "bytes": 22884
     },
     "trigger/trigger-store.d.ts": {
       "sha256": "f846ca66494a2a1b834914652c845373d777bdeaaaefdc101ad1e78083d9ad5b",

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

@@ -148,6 +148,30 @@ function inferMaturity(body) {
     return 'idea';
 }
 async function checkIdempotency(issueNumber, sessionsDir = exports.DEFAULT_SESSIONS_DIR) {
+    const sidecarFilename = `queue-issue-${issueNumber}.json`;
+    const sidecarFilePath = path.join(sessionsDir, sidecarFilename);
+    try {
+        const sidecarContent = await fs.readFile(sidecarFilePath, 'utf8');
+        const sidecarParsed = JSON.parse(sidecarContent);
+        if (typeof sidecarParsed !== 'object' || sidecarParsed === null) {
+            return 'active';
+        }
+        const sidecar = sidecarParsed;
+        const dispatchedAt = sidecar['dispatchedAt'];
+        const ttlMs = sidecar['ttlMs'];
+        if (typeof dispatchedAt === 'number' && typeof ttlMs === 'number') {
+            if (dispatchedAt + ttlMs > Date.now()) {
+                return 'active';
+            }
+            return 'clear';
+        }
+        return 'active';
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT') {
+            return 'active';
+        }
+    }
     let files;
     try {
         files = await fs.readdir(sessionsDir);
@@ -155,7 +179,7 @@ async function checkIdempotency(issueNumber, sessionsDir = exports.DEFAULT_SESSI
     catch {
         return 'clear';
     }
-    const jsonFiles = files.filter(f => f.endsWith('.json'));
+    const jsonFiles = files.filter(f => f.endsWith('.json') && f !== sidecarFilename);
     for (const filename of jsonFiles) {
         try {
             const content = await fs.readFile(path.join(sessionsDir, filename), 'utf8');

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

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

package/dist/trigger/polling-scheduler.js

@@ -38,6 +38,7 @@ 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 adaptive_pipeline_js_1 = require("../coordinators/adaptive-pipeline.js");
 const fs = __importStar(require("node:fs/promises"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
@@ -312,15 +313,31 @@ class PollingScheduler {
         }
         this.dispatchingIssues.add(top.issue.number);
         console.log(`[QueuePoll] in-flight-add #${top.issue.number}`);
+        const sidecarPath = path.join(sessionsDir, `queue-issue-${top.issue.number}.json`);
+        const sidecarContent = JSON.stringify({
+            issueNumber: top.issue.number,
+            triggerId,
+            dispatchedAt: Date.now(),
+            ttlMs: adaptive_pipeline_js_1.DISCOVERY_TIMEOUT_MS + 60000,
+        }, null, 2);
+        void fs.writeFile(sidecarPath, sidecarContent, 'utf8').catch((e) => {
+            console.warn(`[QueuePoll] Failed to write sidecar for issue #${top.issue.number}: ${e instanceof Error ? e.message : String(e)}`);
+        });
         const dispatchP = this.router.dispatchAdaptivePipeline(workflowTrigger.goal, workflowTrigger.workspacePath, workflowTrigger.context);
+        const issueNumber = top.issue.number;
         void dispatchP
-            .then(() => {
-            this.dispatchingIssues.delete(top.issue.number);
-            console.log(`[QueuePoll] in-flight-clear #${top.issue.number} reason=completed`);
+            .then((outcome) => {
+            this.dispatchingIssues.delete(issueNumber);
+            console.log(`[QueuePoll] in-flight-clear #${issueNumber} reason=completed`);
+            if (outcome.kind === 'escalated' || outcome.kind === 'dry_run') {
+                void this.applyGitHubLabel(issueNumber, 'worktrain:in-progress', queueConfig.token, source.repo);
+            }
+            void fs.unlink(sidecarPath).catch(() => { });
         })
             .catch(() => {
-            this.dispatchingIssues.delete(top.issue.number);
-            console.log(`[QueuePoll] in-flight-clear #${top.issue.number} reason=error`);
+            this.dispatchingIssues.delete(issueNumber);
+            console.log(`[QueuePoll] in-flight-clear #${issueNumber} reason=error`);
+            void fs.unlink(sidecarPath).catch(() => { });
         });
         console.log(`[QueuePoll] dispatched via adaptivePipeline goal="${workflowTrigger.goal.slice(0, 80)}"`);
         for (let i = 1; i < candidates.length; i++) {
@@ -332,6 +349,32 @@ class PollingScheduler {
         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() });
     }
+    async applyGitHubLabel(issueNumber, label, token, repo) {
+        const fetchFn = this.fetchFn ?? globalThis.fetch;
+        const url = `https://api.github.com/repos/${repo}/issues/${issueNumber}/labels`;
+        try {
+            const response = await fetchFn(url, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Accept': 'application/vnd.github+json',
+                    'Content-Type': 'application/json',
+                    'X-GitHub-Api-Version': '2022-11-28',
+                },
+                body: JSON.stringify({ labels: [label] }),
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                console.warn(`[QueuePoll] Failed to apply label '${label}' to issue #${issueNumber}: HTTP ${response.status} ${text.slice(0, 200)}`);
+            }
+            else {
+                console.log(`[QueuePoll] Applied label '${label}' to issue #${issueNumber}`);
+            }
+        }
+        catch (e) {
+            console.warn(`[QueuePoll] Failed to apply label '${label}' to issue #${issueNumber}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
 }
 exports.PollingScheduler = PollingScheduler;
 function buildGitLabWorkflowTrigger(trigger, mr) {

package/dist/trigger/trigger-listener.js

@@ -218,7 +218,7 @@ async function startTriggerListener(ctx, options) {
     }
     let routerRef;
     const coordinatorDeps = {
-        spawnSession: async (workflowId, goal, workspace, context) => {
+        spawnSession: async (workflowId, goal, workspace, context, agentConfig) => {
             if (routerRef === undefined) {
                 return { kind: 'err', error: 'in-process router not initialized -- coordinator deps not ready' };
             }
@@ -242,6 +242,7 @@ async function startTriggerListener(ctx, options) {
                 goal,
                 workspacePath: workspace,
                 context,
+                ...(agentConfig !== undefined ? { agentConfig } : {}),
                 _preAllocatedStartResponse: startResult.value.response,
             });
             return { kind: 'ok', value: sessionHandle };

package/dist/trigger/trigger-router.js

@@ -373,7 +373,7 @@ class TriggerRouter {
         return { _tag: 'enqueued', triggerId: trigger.id };
     }
     dispatch(workflowTrigger) {
-        {
+        if (workflowTrigger._preAllocatedStartResponse === undefined) {
             const dedupeKey = `${workflowTrigger.goal}::${workflowTrigger.workspacePath}`;
             const now = Date.now();
             for (const [key, ts] of this._recentAdaptiveDispatches) {
@@ -388,6 +388,9 @@ class TriggerRouter {
             }
             this._recentAdaptiveDispatches.set(dedupeKey, now);
         }
+        else {
+            console.log(`[TriggerRouter] Pre-allocated session dispatched: workflowId=${workflowTrigger.workflowId} goal="${workflowTrigger.goal.slice(0, 60)}"`);
+        }
         void this.queue.enqueue(workflowTrigger.workflowId, async () => {
             if (this.semaphore.activeCount >= this._maxConcurrentSessions) {
                 console.warn(`[TriggerRouter] Concurrency limit reached ` +

package/docs/design/dispatch-dedup-prealloc-bypass-candidates.md

@@ -0,0 +1,187 @@
+# Design Candidates: Bypass Dispatch Dedup for Pre-Allocated Sessions
+
+**Date:** 2026-04-19
+**Status:** Decided -- Option A (guard before dedup block)
+**Scope:** `src/trigger/trigger-router.ts`, `dispatch()` method only
+
+---
+
+## Problem Understanding
+
+### Core Tensions
+
+1. **Dedup protection vs session liveness** -- The 30s dedup window in `dispatch()` exists to prevent
+   duplicate pipeline sessions from webhook retries. But the same mechanism incorrectly kills child
+   sessions spawned by `spawnSession()`, which already pre-created the session in the store via
+   `executeStartWorkflow()`. The invariant 'same key = duplicate' is false for pre-allocated sessions.
+
+2. **Shared state vs path-specific logic** -- `_recentAdaptiveDispatches` is intentionally shared
+   across `route()`, `dispatch()`, and `dispatchAdaptivePipeline()`. This cross-path coupling causes
+   the key collision: `dispatchAdaptivePipeline()` writes `goal::workspace` at t=0, then `dispatch()`
+   reads it at t~=0 and returns early. The fix must carve out an exception for one specific case
+   without breaking the shared-state intent.
+
+3. **Code reuse vs early-exit clarity** -- The dedup block is a scoped `{...}` block at the top of
+   `dispatch()`. Adding the guard before it avoids duplicating the enqueue block, but requires
+   careful restructuring to keep one enqueue call reached by both paths.
+
+### Likely Seam
+
+The real seam is `dispatch()` lines 851-866 (the dedup block). The symptom (zombie session) is
+downstream, but the root cause (early return that bypasses `queue.enqueue()`) is exactly here.
+
+### What Makes It Hard
+
+A junior developer might:
+- Add `_preAllocatedStartResponse` as a new parameter instead of checking the existing field.
+- Delete the dedup block from `dispatch()` entirely (Option B) -- too broad.
+- Add the guard inside the dedup block as a `return` that skips `_recentAdaptiveDispatches.set()`,
+  which is technically acceptable (the map entry from `dispatchAdaptivePipeline()` is still valid
+  for blocking duplicate top-level calls) but less clear.
+- Accidentally duplicate the `queue.enqueue()` callback body, creating divergent result-handling.
+
+---
+
+## Philosophy Constraints
+
+**Source: `/Users/etienneb/CLAUDE.md`**
+
+- **Architectural fixes over patches** -- the guard models the invariant, not a special case
+- **Make illegal states unrepresentable** -- `_preAllocatedStartResponse !== undefined` is a
+  compile-time discriminator; the guard makes 'dedup fires for pre-allocated session' impossible
+- **YAGNI with discipline** -- Option A is the minimal fix; no speculative abstractions
+- **Document why, not what** -- the guard comment must explain the invariant, not describe the code
+
+No conflicts between stated philosophy and repo patterns detected.
+
+---
+
+## Impact Surface
+
+- `spawnSession()` in `src/trigger/trigger-listener.ts` is the only caller that sets
+  `_preAllocatedStartResponse`. The fix must not change its call signature.
+- `queue.enqueue()` callback body in `dispatch()` handles the full `WorkflowRunResult` union
+  (success, error, timeout, stuck, delivery_failed). Both the guard path and the normal path must
+  reach the same callback body -- no duplication.
+- `_recentAdaptiveDispatches` -- for non-prealloc calls, cleanup-on-entry and set must still run.
+- `route()` and `dispatchAdaptivePipeline()` -- no changes to either.
+
+---
+
+## Candidates
+
+### Candidate A: Early-return guard before the dedup block (Option A from design doc)
+
+**Summary:** Add `if (workflowTrigger._preAllocatedStartResponse !== undefined) { void this.queue.enqueue(...); return workflowTrigger.workflowId; }` before the scoped dedup block. The dedup block is only reached when the field is absent.
+
+**Tensions resolved:** Dedup protection vs session liveness (fully resolved for pre-alloc path).
+**Tensions accepted:** Shared state coupling remains -- the map is still shared.
+
+**Boundary solved at:** `dispatch()` entry, before the dedup block. This is the real seam.
+
+**Why this boundary:** The bug fires at the dedup block. The guard is placed exactly where the
+divergence must happen. No other location would be more direct.
+
+**Failure mode:** If the guard path and the normal path have separate `queue.enqueue()` callback
+bodies, any future change to one body must be mirrored to the other. Mitigated by restructuring
+so both paths reach the same enqueue call.
+
+**Repo pattern:** Follows the `dispatchCondition` early-exit pattern in `route()` (lines 641-653).
+Departs in that `dispatch()` previously had no such guard.
+
+**Gains:** Minimal blast radius. Self-documenting -- the guard directly encodes the invariant.
+**Loses:** Slightly more complex method structure if naively implemented with two enqueue blocks.
+
+**Scope:** Best-fit. Single method, single guard.
+
+**Philosophy:** Honors 'Architectural fixes', 'Make illegal states unrepresentable', 'YAGNI'.
+No conflicts.
+
+---
+
+### Candidate B: Wrap dedup block in `if (!_preAllocatedStartResponse)` (same intent, cleaner structure)
+
+**Summary:** Wrap the entire scoped dedup block in `if (workflowTrigger._preAllocatedStartResponse === undefined)`. Both paths then fall through to the same `void this.queue.enqueue(...)` call at the bottom of the method.
+
+**Tensions resolved:** Same as A, plus eliminates code duplication risk.
+**Tensions accepted:** Same as A.
+
+**Boundary:** Same as A.
+
+**Failure mode:** `_recentAdaptiveDispatches.set()` must still run for non-prealloc paths that
+pass dedup. This is naturally handled by the wrap -- the set is inside the block.
+
+**Repo pattern:** More consistent with the existing scoped-block style in `dispatch()`.
+
+**Gains:** Single enqueue block -- no duplication risk.
+**Loses:** The `_preAllocatedStartResponse` check is farther from the enqueue call than in A,
+making the intent slightly less immediate.
+
+**Scope:** Best-fit. Same scope as A.
+
+**Philosophy:** Same as A.
+
+---
+
+### Candidate C: Remove dedup from `dispatch()` entirely (Option B from design doc)
+
+**Summary:** Delete the entire dedup block from `dispatch()`. The dedup that protects against
+webhook retries lives in `dispatchAdaptivePipeline()` and `route()`, both of which are the
+actual entry points for external events.
+
+**Tensions resolved:** Eliminates the shared-state coupling entirely.
+
+**Boundary:** Too broad -- removes protection from the HTTP console route at `console-routes.ts:868`
+which calls `dispatch()` directly.
+
+**Failure mode:** Rapid-fire console dispatches could spawn duplicates if the HTTP layer does not
+deduplicate. No evidence exists that this protection is currently needed, but removing it is a
+behavioral change beyond the scope of this fix.
+
+**Repo pattern:** Departs from the established shared-dedup-map pattern.
+
+**Scope:** Too broad. The task explicitly specifies Option A.
+
+**Philosophy:** Conflicts with 'YAGNI with discipline' -- speculative fix for an unproven gap.
+
+---
+
+## Comparison and Recommendation
+
+All three candidates converge on the same fundamental fix. C is ruled out (too broad). A and B
+are structurally equivalent -- the choice is whether to use an early-return guard (A) or a
+wrapping if-block (B).
+
+**Recommendation: Implement B's structure with A's intent.**
+
+Use `if (workflowTrigger._preAllocatedStartResponse === undefined)` to wrap the dedup block,
+with the `void this.queue.enqueue(...)` call appearing once after the if-block. This gives:
+- No code duplication (single enqueue call)
+- Clear separation: 'if non-prealloc, check dedup; then enqueue regardless'
+- Consistent with the scoped-block style already in `dispatch()`
+
+**Rationale:** The task pseudocode suggests A's early-return pattern, but B is equivalent and
+avoids the duplication risk. Any reviewer familiar with the design doc will understand either shape.
+
+---
+
+## Self-Critique
+
+**Strongest counter-argument:** The task pseudocode explicitly shows an early-return guard (A).
+A reviewer seeing the design doc side-by-side with the implementation may expect exactly that
+pattern. Diverging to a wrap (B) adds a tiny friction.
+
+**Pivot conditions:**
+- If the enqueue callback body diverges between paths in A, switch to B immediately.
+- If `dispatch()` gains a third call path that also needs dedup bypass, consider Option C or
+  a separate dedup map (Option C from design doc) at that point.
+
+**Assumption that would invalidate this design:** If `_preAllocatedStartResponse` could ever be
+set on a call where dedup should still fire. The JSDoc is explicit: the field is only set by
+`spawnSession`/`spawn_agent` which already hold a pre-created session. This assumption is safe.
+
+---
+
+## Open Questions for the Main Agent
+
+None. The problem, solution, boundary, and tests are fully specified.

package/docs/design/dispatch-dedup-prealloc-bypass-design-review.md

@@ -0,0 +1,100 @@
+# Design Review: Bypass Dispatch Dedup for Pre-Allocated Sessions
+
+**Date:** 2026-04-19
+**Reviewer:** Claude (automated design review pass)
+**Selected approach:** Wrap dedup block in `if (workflowTrigger._preAllocatedStartResponse === undefined)`
+
+---
+
+## Tradeoff Review
+
+### Shared dedup map stays shared
+
+The `_recentAdaptiveDispatches` map remains shared across all dispatch paths. Pre-alloc calls
+bypass the check but do not update the map.
+
+**Assessment:** Sound. The map entry from `dispatchAdaptivePipeline()` correctly blocks duplicate
+top-level pipelines for 30s. Pre-alloc calls are child sessions -- they should not add new map
+entries. All cross-path scenarios analyzed; no violations found.
+
+**Condition for unacceptability:** If a legitimate retry of the same goal+workspace (without
+pre-alloc) must fire within 30s of the original dispatch. Unlikely in practice; TTL is 30s.
+
+### Comment is the only regression protection
+
+The guard `if (_preAllocatedStartResponse === undefined)` wrapping the dedup block has no
+compile-time enforcement beyond the unit test.
+
+**Assessment:** Acceptable. The unit test `dispatch() with _preAllocatedStartResponse bypasses
+dedup and calls runWorkflowFn` catches any regression. The JSDoc on the field and the guard
+comment provide documentation-level protection.
+
+---
+
+## Failure Mode Review
+
+| Mode | Handled? | Mitigation |
+|---|---|---|
+| Guard removed in refactor | Yes | Unit test catches it |
+| Falsy check instead of `!== undefined` | Non-issue | Type is always an object when present |
+| Semaphore deadlock | Not new risk | Pre-existing FIFO semaphore handles this |
+| Session completes before enqueue | Not real | executeStartWorkflow doesn't run agent loop |
+
+**Highest-risk:** Guard removed in refactor. Mitigated by unit test.
+
+---
+
+## Runner-Up / Simpler Alternative Review
+
+- **Runner-up (early-return guard A):** Structurally equivalent. Loses because B keeps a single
+  enqueue block, reducing duplication risk. No elements worth borrowing beyond the guard comment.
+- **Simpler alternative (extract `_enqueueDispatch`):** Would be cleaner but is out of scope for
+  this targeted fix. No correctness benefit.
+
+---
+
+## Philosophy Alignment
+
+All relevant CLAUDE.md principles are satisfied:
+- **Architectural fixes over patches** -- the guard models the root invariant
+- **Make illegal states unrepresentable** -- compile-time discriminator
+- **YAGNI with discipline** -- minimal change, no speculation
+- **Document why, not what** -- guard comment explains invariant
+
+Pre-existing tensions (mutable shared map) are not introduced by this fix.
+
+---
+
+## Findings
+
+**No RED findings.** No blocking issues detected.
+
+**ORANGE (advisory):**
+1. The guard comment must be explicit about WHY dedup is bypassed, not just THAT it is bypassed.
+   A vague comment like `// skip dedup for pre-alloc` is insufficient. The comment must state:
+   'executeStartWorkflow already created the session in the store; dropping this dispatch would
+   zombie it.'
+
+**YELLOW (notes):**
+1. The unit test for the bypass case should assert that `runWorkflowFn` is called exactly once
+   (not just called), to verify the session actually starts.
+2. Consider adding a log line in the bypass path: `console.log('[TriggerRouter] Pre-allocated session dispatched: workflowId=...')` for observability.
+
+---
+
+## Recommended Revisions
+
+1. Write the guard comment to match the invariant stated in the design doc:
+   ```typescript
+   // Pre-allocated session: executeStartWorkflow already created the session in the store.
+   // Deduplication must not apply here -- dropping this dispatch would zombie the session.
+   ```
+2. In the test: assert `calls` has exactly 1 entry (`toHaveLength(1)`) after the bypass dispatch.
+3. Optional: add a `console.log` in the bypass path for daemon observability.
+
+---
+
+## Residual Concerns
+
+None. The fix is sound, minimal, and directly models the documented invariant. All failure modes
+are either handled or pre-existing. The design is ready for implementation.