@exaudeus/workrail 3.52.0 → 3.54.0

package/dist/manifest.json

@@ -238,8 +238,8 @@
       "bytes": 31
     },
     "cli-worktrain.js": {
-      "sha256": "4f68c32b88c84d71d7a28b4ffd818d2612e5a8c61c9f59edd4415772dfd5b9ab",
-      "bytes": 50057
+      "sha256": "8af6e8703639f67d1b1cda43fe533e3622e0d3805be08aa6b2e4053eeec59ae7",
+      "bytes": 51346
     },
     "cli.d.ts": {
       "sha256": "43e818adf60173644896298637f47b01d5819b17eda46eaa32d0c7d64724d012",
@@ -362,12 +362,12 @@
       "bytes": 12528
     },
     "cli/commands/worktrain-overview.d.ts": {
-      "sha256": "04ba3abc659a219dc05893739c0b9c4797c5a45a67bc26647c17ab0db79c0d52",
-      "bytes": 1327
+      "sha256": "d9cb907b57aaa19ee5654c1726a33cdc6b7a54e3bd24dd8f2900d18491dd94a3",
+      "bytes": 1393
     },
     "cli/commands/worktrain-overview.js": {
-      "sha256": "0987dcb2518dfd44d103dd0958abae4c7e8323f314971ffdc3ead320c4c8eef9",
-      "bytes": 6764
+      "sha256": "deb7e2a3fb76fbe89479b07fac69df3b8bb0cd06d63fb6a8a73046886ff7b3a7",
+      "bytes": 9483
     },
     "cli/commands/worktrain-pipeline.d.ts": {
       "sha256": "ea0b36c853002352c7fad167c90dcf0234d2ec1a1fb042d4fd749531c7733fc0",
@@ -465,8 +465,8 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console-ui/assets/index-Ce7Feod7.js": {
-      "sha256": "4db4d03fa5fbc1e7ea2a1abac8e29cce1596beed8a4daf3a26b9237eac80128c",
+    "console-ui/assets/index-CoXPahi0.js": {
+      "sha256": "4318a19db292a33a0001ddce4540b7120b621606a8169f3c7812c27c8d6232cc",
       "bytes": 760528
     },
     "console-ui/assets/index-DGj8EsFR.css": {
@@ -474,7 +474,7 @@
       "bytes": 60631
     },
     "console-ui/index.html": {
-      "sha256": "2169487225f552787e2a3273d8fe6ac797e171846a6dd7b98099006b1a5aa787",
+      "sha256": "ff31b9cb7ebf0123369286b6a7dc91fbc31fa34afc6fe0cc2d8a04f3f1ee2687",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -597,9 +597,17 @@
       "sha256": "aa47bea99cf9a5ce35d2bc375b6dd51a9fbb68d36f2b185ee0a98176f67d647d",
       "bytes": 9803
     },
+    "daemon/daemon-env.d.ts": {
+      "sha256": "4546caacd79c21b162d2d03c1cde24d4f6d232e684229828722be75d4a33920a",
+      "bytes": 213
+    },
+    "daemon/daemon-env.js": {
+      "sha256": "287a66c96730857e06375da299bf8a6d61aaf53080d94cbdbac9f0428a55a6fb",
+      "bytes": 1216
+    },
     "daemon/daemon-events.d.ts": {
-      "sha256": "8157d89411cb535d3c08d1f0a94a7bd9b5fa4934777133c0217917f83e56d95e",
-      "bytes": 4488
+      "sha256": "bfdc842cdb54a81207d88d8315a1f5e9500ac5da9265b0e4f2e9252636bd0a3a",
+      "bytes": 4820
     },
     "daemon/daemon-events.js": {
       "sha256": "b6841eef4634bb266faf81961c1e387b535dd64a74d58582f3f2bad8c3469d95",
@@ -1666,8 +1674,8 @@
       "bytes": 800
     },
     "trigger/github-queue-config.js": {
-      "sha256": "dd508fc3f9f58a70cdc076029154a3c1610569c611471e9b67bf1cd4be64a520",
-      "bytes": 7347
+      "sha256": "1971310c5d8519efc22f627f3eb56c9e5e457fc90da9e32cbd09a1bbfd3cb6a8",
+      "bytes": 7353
     },
     "trigger/index.d.ts": {
       "sha256": "a9cfd053714173e2a8cc5a282fd5b09a5c3f3001304d507facd0e12de9cc0733",
@@ -1698,8 +1706,8 @@
       "bytes": 792
     },
     "trigger/polling-scheduler.js": {
-      "sha256": "dd5532f3dff75377685fb68d78820cb5916f823626b91d6306ad7aa3d9801be5",
-      "bytes": 20188
+      "sha256": "49b4f8b82f21d336365d5a82aa10f4541792d3a4f84c21ff0db34034f8290626",
+      "bytes": 20312
     },
     "trigger/trigger-listener.d.ts": {
       "sha256": "92e971ab8f47c3c867860cffc01f54c4aae54fcc4ae199b9469210f4ce639423",
@@ -1714,20 +1722,20 @@
       "bytes": 2671
     },
     "trigger/trigger-router.js": {
-      "sha256": "eab2a12e9e7c5b5ef425096883e23bf12937c6838b13ea455c8f560855d9b9c6",
-      "bytes": 19264
+      "sha256": "b7a375a50c5d9bcae8afb22fde1a05f63320343b9fe82541852fa0de1201467e",
+      "bytes": 19850
     },
     "trigger/trigger-store.d.ts": {
       "sha256": "7afb05127d55bc3757a550dd15d4b797766b3fff29d1bfe76b303764b93322e7",
       "bytes": 1588
     },
     "trigger/trigger-store.js": {
-      "sha256": "7d1a61e6f0e01fd256f128f1fc223c0846eb020a87123bd03d2c31189f65c87b",
-      "bytes": 38830
+      "sha256": "6c3c53bc553b8e5fef67cd907d34794309f7505994afa37f7a5dcac575e1f941",
+      "bytes": 42387
     },
     "trigger/types.d.ts": {
-      "sha256": "dc80ac05c031f24d5916bf95319dbe73262e1ada5aa5f83bedbfe6851188f8b1",
-      "bytes": 3689
+      "sha256": "b5fe2d2ebc1da0e27211c1321539456ab346300007f29f157bff2f774e284048",
+      "bytes": 3802
     },
     "trigger/types.js": {
       "sha256": "45b4e4f23a6d1a2b07350196871b0c53840e5d8142b47f7acedd2f40ae7a6b73",

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

@@ -39,7 +39,7 @@ 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');
+exports.WORKRAIL_CONFIG_PATH = path.join(os.homedir(), '.workrail', 'queue-config.json');
 async function loadQueueConfig(configPath = exports.WORKRAIL_CONFIG_PATH, env = process.env) {
     let raw;
     try {

package/dist/trigger/polling-scheduler.js

@@ -286,14 +286,13 @@ class PollingScheduler {
         const maturityReason = describeMaturityReason(top.maturity);
         console.log(`[QueuePoll] selected #${top.issue.number} "${top.issue.title}" maturity=${top.maturity} reason="${maturityReason}"`);
         await appendQueuePollLog({ event: 'task_selected', issueNumber: top.issue.number, title: top.issue.title, maturity: top.maturity, reason: maturityReason, ts: new Date().toISOString() });
-        if ('dispatchAdaptivePipeline' in this.router &&
-            typeof this.router.dispatchAdaptivePipeline === 'function') {
-            void this.router.dispatchAdaptivePipeline(workflowTrigger.goal, workflowTrigger.workspacePath, workflowTrigger.context);
-            console.log(`[QueuePoll] dispatched via adaptivePipeline goal="${workflowTrigger.goal.slice(0, 80)}"`);
-        }
-        else {
-            this.router.dispatch(workflowTrigger);
+        if (typeof this.router.dispatchAdaptivePipeline !== 'function') {
+            throw new Error('[QueuePoll] dispatchAdaptivePipeline not available on router. ' +
+                'Queue poll triggers require the adaptive coordinator. ' +
+                'Inject coordinatorDeps and modeExecutors in the TriggerRouter constructor.');
         }
+        void this.router.dispatchAdaptivePipeline(workflowTrigger.goal, workflowTrigger.workspacePath, workflowTrigger.context);
+        console.log(`[QueuePoll] dispatched via adaptivePipeline goal="${workflowTrigger.goal.slice(0, 80)}"`);
         for (let i = 1; i < candidates.length; i++) {
             const { issue, maturity } = candidates[i];
             console.log(`[QueuePoll] skipped #${issue.number} "${issue.title}" reason=lower_priority_${maturity}`);

package/dist/trigger/trigger-router.js

@@ -255,6 +255,16 @@ class TriggerRouter {
                 return { _tag: 'error', error: { kind: 'hmac_invalid' } };
             }
         }
+        if (trigger.dispatchCondition) {
+            const { payloadPath, equals } = trigger.dispatchCondition;
+            const extracted = extractDotPath(event.payload, payloadPath);
+            if (extracted !== equals) {
+                const actual = extracted === undefined ? 'undefined' : String(extracted);
+                console.log(`[TriggerRouter] dispatch skipped: condition not met ` +
+                    `(${payloadPath}=${actual} !== ${equals}) for triggerId=${trigger.id}`);
+                return { _tag: 'enqueued', triggerId: trigger.id };
+            }
+        }
         let workflowContext;
         if (trigger.contextMapping?.mappings.length) {
             workflowContext = applyContextMapping(event.payload, trigger.contextMapping.mappings);

package/dist/trigger/trigger-store.js

@@ -268,6 +268,50 @@ function parseTriggersYaml(content) {
                 trigger.onComplete = onComplete;
                 continue;
             }
+            if (key === 'dispatchCondition') {
+                lineIndex++;
+                const dispatchCondition = {};
+                while (lineIndex < lines.length) {
+                    const dcLine = lines[lineIndex];
+                    if (dcLine === undefined)
+                        break;
+                    const dcTrimmed = dcLine.trim();
+                    if (dcTrimmed === '' || dcTrimmed.startsWith('#')) {
+                        lineIndex++;
+                        continue;
+                    }
+                    const dcIndent = dcLine.search(/\S/);
+                    if (dcIndent <= lineIndent)
+                        break;
+                    const dcColonIdx = dcTrimmed.indexOf(':');
+                    if (dcColonIdx === -1) {
+                        return (0, result_js_1.err)({
+                            kind: 'parse_error',
+                            message: `Missing colon in dispatchCondition entry at line ${lineIndex + 1}: "${dcTrimmed}"`,
+                            lineNumber: lineIndex + 1,
+                        });
+                    }
+                    const dcKey = dcTrimmed.slice(0, dcColonIdx).trim();
+                    const dcRawValue = dcTrimmed.slice(dcColonIdx + 1).trim();
+                    if (dcRawValue !== '') {
+                        const dcValueResult = parseScalar(dcRawValue, lineIndex + 1);
+                        if (dcValueResult.kind === 'err')
+                            return dcValueResult;
+                        switch (dcKey) {
+                            case 'payloadPath':
+                                dispatchCondition.payloadPath = dcValueResult.value;
+                                break;
+                            case 'equals':
+                                dispatchCondition.equals = dcValueResult.value;
+                                break;
+                            default: break;
+                        }
+                    }
+                    lineIndex++;
+                }
+                trigger.dispatchCondition = dispatchCondition;
+                continue;
+            }
             if (key === 'source') {
                 lineIndex++;
                 const source = {};
@@ -441,9 +485,9 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
     if (!rawId) {
         return (0, result_js_1.err)({ kind: 'missing_field', field: 'id', triggerId: '(unknown)' });
     }
+    const isQueuePollProvider = raw.provider?.trim() === 'github_queue_poll';
     const requiredStringFields = [
         'provider',
-        'workflowId',
     ];
     for (const field of requiredStringFields) {
         const v = raw[field];
@@ -451,6 +495,15 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
             return (0, result_js_1.err)({ kind: 'missing_field', field, triggerId: rawId });
         }
     }
+    if (!isQueuePollProvider && !raw.workflowId?.trim()) {
+        return (0, result_js_1.err)({ kind: 'missing_field', field: 'workflowId', triggerId: rawId });
+    }
+    if (isQueuePollProvider && raw.workflowId?.trim()) {
+        console.warn(`[TriggerStore] WARNING: trigger "${rawId}" has provider='github_queue_poll' and ` +
+            `workflowId='${raw.workflowId.trim()}'. For queue poll triggers, workflowId is ignored -- ` +
+            `the adaptive coordinator determines the pipeline based on task content. ` +
+            `You can remove workflowId from this trigger definition.`);
+    }
     const provider = raw.provider.trim();
     if (!SUPPORTED_PROVIDERS.has(provider)) {
         return (0, result_js_1.err)({ kind: 'unknown_provider', provider, triggerId: rawId });
@@ -808,10 +861,23 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
             `defines a source: block. The source: block is only used for polling providers ` +
             `(gitlab_poll, github_issues_poll, github_prs_poll, github_queue_poll). It will be ignored for this trigger.`);
     }
+    const resolvedWorkflowId = raw.workflowId?.trim() ?? '';
+    let dispatchCondition;
+    if (raw.dispatchCondition) {
+        const rawDcPayloadPath = raw.dispatchCondition.payloadPath?.trim();
+        const rawDcEquals = raw.dispatchCondition.equals?.trim();
+        if (!rawDcPayloadPath) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'dispatchCondition.payloadPath', triggerId: rawId });
+        }
+        if (rawDcEquals === undefined || rawDcEquals === '') {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'dispatchCondition.equals', triggerId: rawId });
+        }
+        dispatchCondition = { payloadPath: rawDcPayloadPath, equals: rawDcEquals };
+    }
     const trigger = {
         id: (0, types_js_1.asTriggerId)(rawId),
         provider,
-        workflowId: raw.workflowId.trim(),
+        workflowId: resolvedWorkflowId,
         workspacePath: resolvedWorkspacePath,
         goal: resolvedGoal,
         concurrencyMode,
@@ -833,6 +899,7 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
         ...(branchStrategy !== undefined ? { branchStrategy } : {}),
         ...(baseBranch !== undefined ? { baseBranch } : {}),
         ...(branchPrefix !== undefined ? { branchPrefix } : {}),
+        ...(dispatchCondition !== undefined ? { dispatchCondition } : {}),
     };
     return (0, result_js_1.ok)(trigger);
 }

package/dist/trigger/types.d.ts

@@ -69,6 +69,10 @@ export interface TriggerDefinition {
     readonly contextMapping?: ContextMapping;
     readonly goalTemplate?: string;
     readonly referenceUrls?: readonly string[];
+    readonly dispatchCondition?: {
+        readonly payloadPath: string;
+        readonly equals: string;
+    };
     readonly agentConfig?: {
         readonly model?: string;
         readonly maxSessionMinutes?: number;

package/docs/design/dispatch-condition-and-adaptive-queue.md

@@ -0,0 +1,97 @@
+# Design: dispatchCondition Filter and Adaptive Queue Routing
+
+## Problem Understanding
+
+### Tensions
+
+1. **Silent skip vs new API surface**: When `dispatchCondition` is not met, the HTTP caller already received a 202 response. Adding a new `_tag: 'skipped'` to `RouteResult` would require HTTP handler changes (the 202 was already sent). Reusing `{ _tag: 'enqueued' }` preserves the existing API contract with zero surface change. Observability is provided via a log line.
+
+2. **Backward compat vs clean schema for `workflowId` on queue triggers**: `workflowId: string` is required in `TriggerDefinition`. Making it optional (`string | undefined`) would cascade to all callers: `dispatch()` queue key, `maybeRunDelivery()` attribution, `WorkflowTrigger.workflowId`. Using a `''` sentinel keeps the interface unchanged while allowing queue poll triggers to omit `workflowId` in YAML.
+
+3. **Type guard vs hard failure for `dispatchAdaptivePipeline`**: The existing type-guard pattern (`'dispatchAdaptivePipeline' in this.router`) allows test fakes that only implement `dispatch()`. The new requirement is to throw when `dispatchAdaptivePipeline` is unavailable. This changes a soft-fallback to a hard failure -- intentional for production correctness.
+
+4. **Validate at boundary vs trust inside**: `dispatchCondition.payloadPath` and `dispatchCondition.equals` must both be validated as present strings at parse time (trigger-store.ts), not at dispatch time (trigger-router.ts). This follows the existing pattern for all parsed fields.
+
+### Likely Seam
+
+- **`dispatchCondition` check**: `route()` in trigger-router.ts, after HMAC validation, before context mapping. This is the correct seam -- HMAC validates authenticity, then condition gates dispatch, then context mapping applies to trusted+relevant payloads.
+- **Adaptive routing**: `doPollGitHubQueue()` in polling-scheduler.ts. The queue poller owns the process and calls the coordinator as a function.
+
+### What Makes It Hard
+
+- `extractDotPath()` in trigger-router.ts is a private module function -- but `dispatchCondition` check is in the same file, so it's directly accessible.
+- The YAML parser's sub-object block handling requires adding `dispatchCondition` as a named key case BEFORE the `if (rawValue === '')` early-skip falls through. If we miss this, `dispatchCondition:` (empty value) silently skips the block.
+- `workflowId` required-field check runs before provider validation in `validateAndResolveTrigger`. Must restructure slightly to skip `workflowId` check for `github_queue_poll`.
+
+## Philosophy Constraints
+
+**Honored:**
+- Immutability by default -- new `dispatchCondition` fields are `readonly`
+- Validate at boundaries -- `payloadPath` and `equals` validated at parse time in trigger-store.ts
+- YAGNI with discipline -- equals-only MVP, no regex/AND/OR
+- Exhaustiveness -- no new `RouteResult` variants (reuse `enqueued`)
+- Document 'why' -- comments explain the skip behavior and the backward-compat warning
+
+**Conflict:**
+- 'Errors are data' vs throw for missing `dispatchAdaptivePipeline`: the spec explicitly requires a throw rather than returning a Result. Rationale: misconfiguration at construction time is a programmer error, not a domain error. Spec overrides philosophy here.
+
+## Impact Surface
+
+- `TriggerDefinition` (types.ts): new optional field, no breaking change
+- `ParsedTriggerRaw` (trigger-store.ts): new `dispatchCondition` sub-object, YAML block parser, validation
+- `route()` (trigger-router.ts): new `dispatchCondition` check after HMAC
+- `doPollGitHubQueue()` (polling-scheduler.ts): removes type-guard fallback
+- Tests: new tests in trigger-router.test.ts and polling-scheduler.test.ts
+- **Not affected**: `src/mcp/`, `WorkflowTrigger`, `RouteResult` type shape (same variants), `maybeRunDelivery`
+
+## Candidates
+
+### Candidate 1: Exact Spec Implementation (Selected)
+
+**Summary:** Add `dispatchCondition` as a sub-object block in trigger-store.ts (following `agentConfig` pattern), check in `route()` after HMAC using existing `extractDotPath()`, use `''` sentinel for `workflowId` in queue poll, throw Error in `doPollGitHubQueue` when `dispatchAdaptivePipeline` unavailable.
+
+**Tensions resolved:** Silent skip (enqueued tag reuse), backward compat (no interface change), scope control (4 files only).
+
+**Tensions accepted:** Slight looseness from `''` sentinel (not a true optional), philosophy conflict on throw vs Result.
+
+**Boundary:** All 4 trigger files. No cross-file interface changes.
+
+**Why best-fit:** `WorkflowTrigger.workflowId` is also `string` (required), so making `TriggerDefinition.workflowId` optional would cascade to `WorkflowTrigger` and all builders. Queue poll never uses `workflowId` in its dispatch path (calls `dispatchAdaptivePipeline(goal, workspace, context)` directly), so the sentinel has zero runtime impact.
+
+**Failure mode:** `''` sentinel leaks into delivery logs if queue poll somehow runs `maybeRunDelivery`. Mitigated: queue triggers don't set `autoCommit: true` and `maybeRunDelivery` gates on `result._tag === 'success'` from `runWorkflowFn`, which is never called for queue poll (adaptive coordinator handles dispatch).
+
+**Repo pattern:** Follows `agentConfig` block parsing exactly. Follows `validateHmac` early-return pattern. Adapts `dispatchAdaptivePipeline` Option B design.
+
+**Gains:** Minimal blast radius, zero interface churn, backward compatible.
+
+**Gives up:** Type-level optionality for `workflowId` in queue triggers.
+
+**Scope:** Best-fit -- 4 files, no cascades.
+
+**Philosophy:** Honors immutability, validate at boundaries, YAGNI. One conflict: throw vs Result (spec overrides).
+
+---
+
+### Candidate 2: `workflowId?: string` Optional in TriggerDefinition (Rejected)
+
+**Summary:** Make `workflowId` optional at the type level, handle `undefined` at all callsites.
+
+**Rejected because:** Cascades to `WorkflowTrigger.workflowId` (also required), `dispatch()` queue key, `maybeRunDelivery` attribution, all three `build*WorkflowTrigger` helpers. Unnecessary churn for a field that is simply unused in the queue poll path. Scope is too broad.
+
+## Comparison and Recommendation
+
+Candidate 1 is the clear winner. Candidate 2 is too broad. No other candidates are meaningfully different.
+
+**Recommendation: Candidate 1.**
+
+## Self-Critique
+
+**Strongest counter-argument:** The `''` sentinel is an implicit contract. A future developer reading `trigger.workflowId === ''` in a log won't know it means 'queue poll, adaptive routing'. A comment in the code mitigates this.
+
+**Pivot conditions:**
+- If a future feature needs to dispatch queue poll triggers to specific workflows (not just adaptive), `workflowId` would become meaningful again. At that point, add explicit support rather than reactivating the ignored field.
+- If `WorkflowTrigger.workflowId` becomes optional in a future refactor, revisit making `TriggerDefinition.workflowId` optional too.
+
+## Open Questions for the Main Agent
+
+None. The spec is fully prescriptive. The only implementation decision (sentinel vs optional) is resolved above.

package/docs/design/dispatch-condition-implementation-plan.md

@@ -0,0 +1,168 @@
+# Implementation Plan: dispatchCondition Filter and Adaptive Queue Routing
+
+## Problem Statement
+
+Two deficiencies in the trigger system:
+1. Generic webhook triggers have no payload-based dispatch filter. In queue use cases (e.g., only fire when `assignee.login === 'worktrain-etienneb'`), every webhook fires regardless of payload content.
+2. `github_queue_poll` triggers can silently fall back to `dispatch()` instead of always routing through the adaptive coordinator. This is wrong -- queue poll sessions MUST always use the adaptive coordinator.
+
+## Acceptance Criteria
+
+1. `TriggerDefinition.dispatchCondition` field exists with `payloadPath: string` and `equals: string` subfields (both `readonly`)
+2. `dispatchCondition` is parsed from triggers.yml sub-object block (same syntax as `agentConfig`)
+3. `dispatchCondition.payloadPath` and `dispatchCondition.equals` are validated as required strings when the block is present
+4. In `route()`, when `dispatchCondition` is set and the extracted payload value does NOT strictly equal `equals`: return `{ _tag: 'enqueued' }` silently (no dispatch) with a debug log
+5. When condition IS met (or absent): dispatch proceeds normally
+6. `doPollGitHubQueue()` ALWAYS calls `dispatchAdaptivePipeline()` -- never falls back to `dispatch()`
+7. When `dispatchAdaptivePipeline` is unavailable: throw Error with clear message (NOT silent fallback)
+8. `workflowId` is no longer required in triggers.yml for `github_queue_poll` providers
+9. Existing triggers.yml files with `workflowId` on a queue trigger still parse without error (log warning it's ignored)
+10. `npm run build` clean
+11. All specified tests pass, no regressions in `npx vitest run`
+
+## Non-Goals
+
+- No regex matching in `dispatchCondition` (MVP: equals-only)
+- No AND/OR or nested conditions
+- No changes to `src/mcp/` (scope locked to 4 trigger files)
+- No changes to `RouteResult` type variants (reuse `enqueued` for skipped)
+- No changes to `WorkflowTrigger.workflowId` type signature
+
+## Philosophy-Driven Constraints
+
+- All new fields in `TriggerDefinition`: `readonly`
+- Validate `dispatchCondition` at parse time (trigger-store.ts), not at dispatch time
+- Use strict identity (`===`) for `dispatchCondition` comparison -- no type coercion
+- Comment at `workflowId` sentinel explaining why `''` is safe
+- Throw for missing `dispatchAdaptivePipeline` (programmer error, not domain error)
+
+## Invariants
+
+1. `dispatchCondition` absent = always dispatch (current behavior, unchanged)
+2. `dispatchCondition.payloadPath` and `dispatchCondition.equals` always co-present (validated at parse time)
+3. `dispatchCondition` check runs AFTER HMAC validation, BEFORE context mapping application
+4. `route()` return type never changes -- `{ _tag: 'enqueued' }` for both dispatch and skip
+5. `doPollGitHubQueue()` never calls `this.router.dispatch()` -- always `dispatchAdaptivePipeline`
+6. `workflowId: ''` sentinel for queue poll -- never forwarded to adaptive dispatcher (only goal/workspace/context)
+7. Throw from `doPollGitHubQueue` is caught by `runPollCycle` try/catch -- not a daemon crash
+
+## Selected Approach
+
+**Candidate 1: Exact spec implementation with FM5 correction (strict equals)**
+
+- `types.ts`: Add `dispatchCondition?: { readonly payloadPath: string; readonly equals: string }` to `TriggerDefinition`
+- `trigger-store.ts`: Add `dispatchCondition` sub-object block to YAML parser (like `agentConfig`), validate both fields present, assemble onto `TriggerDefinition`
+- `trigger-router.ts`: After HMAC check in `route()`, if `trigger.dispatchCondition` set, extract via `extractDotPath()`, check `extracted === condition.equals`, return `{ _tag: 'enqueued' }` with debug log if mismatch
+- `polling-scheduler.ts`: Remove type-guard fallback in `doPollGitHubQueue()`, always call `dispatchAdaptivePipeline`, throw Error if unavailable
+
+**Runner-up rejected:** Optional `workflowId` -- cascades to WorkflowTrigger and all builders, unnecessary blast radius.
+
+## Vertical Slices
+
+### Slice 1: types.ts -- Add dispatchCondition to TriggerDefinition
+- Add JSDoc comment explaining purpose, payloadPath syntax, when absent behavior
+- Both fields `readonly string`
+- File: `src/trigger/types.ts`
+- Done when: TypeScript compiles, new field visible in TriggerDefinition
+
+### Slice 2: trigger-store.ts -- Parse and validate dispatchCondition
+- Add `dispatchCondition?: { payloadPath?: string; equals?: string }` to `ParsedTriggerRaw`
+- Add `'dispatchCondition'` to `setTriggerField` as known key (maps to sub-object block)
+- Add `if (key === 'dispatchCondition')` block handler in YAML parser (before `rawValue === ''` check)
+- Validate both payloadPath and equals present strings when block set, return TriggerStoreError if either missing
+- Assemble onto TriggerDefinition in trigger assembly block
+- Add workflowId conditional skip for github_queue_poll (with backward-compat warning when present)
+- File: `src/trigger/trigger-store.ts`
+- Done when: valid YAML with dispatchCondition parses correctly; missing field returns error; queue poll without workflowId parses; queue poll with workflowId logs warning
+
+### Slice 3: trigger-router.ts -- Check dispatchCondition in route()
+- After HMAC validation block, before context mapping
+- Extract via `extractDotPath(event.payload, condition.payloadPath)`
+- If `extracted !== condition.equals`: log `[TriggerRouter] dispatch skipped: condition not met (${payloadPath}=${actual} !== ${equals})`, return `{ _tag: 'enqueued', triggerId: trigger.id }`
+- Strictly BEFORE `workflowContext` building and `workflowTrigger` object construction
+- File: `src/trigger/trigger-router.ts`
+- Done when: condition check blocks dispatch; matching condition allows dispatch; absent condition dispatches normally
+
+### Slice 4: polling-scheduler.ts -- Always use adaptive, throw when unavailable
+- Remove the type-guard `if ('dispatchAdaptivePipeline' in this.router && typeof ...) { ... } else { this.router.dispatch(workflowTrigger); }` block
+- Replace with: check if `typeof (this.router as { dispatchAdaptivePipeline?: unknown }).dispatchAdaptivePipeline !== 'function'` -> throw Error
+- Then call `await this.router.dispatchAdaptivePipeline(workflowTrigger.goal, workflowTrigger.workspacePath, workflowTrigger.context)`
+- Add comment: `// Always use adaptive pipeline for queue poll triggers. workflowId from triggers.yml is intentionally ignored -- the adaptive coordinator decides the pipeline based on task content.`
+- File: `src/trigger/polling-scheduler.ts`
+- Done when: adaptive always called; test fake without method causes throw; log line updated
+
+### Slice 5: Tests
+- **trigger-router.test.ts**: 3 new tests for dispatchCondition
+- **polling-scheduler.test.ts**: 2 new tests for queue poll adaptive routing + update existing fakes
+- Files: `tests/unit/trigger-router.test.ts`, `tests/unit/polling-scheduler.test.ts`
+- Done when: all 5 new tests pass; existing tests pass; no regressions
+
+## Test Design
+
+### Tests to Update in polling-scheduler.test.ts
+- `makeRouter()` function: add `dispatchAdaptivePipeline: vi.fn().mockResolvedValue({ kind: 'merged' })` to the fake router object. Existing tests that use `makeRouter()` for gitlab_poll/github triggers won't be affected (doPollGitHub doesn't use this method).
+
+### New Tests
+
+**trigger-router.test.ts:**
+```typescript
+describe('TriggerRouter.route dispatchCondition', () => {
+  it('dispatches when dispatchCondition is met (extracted value equals condition.equals)', async () => {
+    // trigger with dispatchCondition: { payloadPath: '$.assignee.login', equals: 'worktrain-bot' }
+    // payload: { assignee: { login: 'worktrain-bot' } }
+    // expect: runWorkflow called
+  });
+  it('skips dispatch when dispatchCondition not met (wrong value)', async () => {
+    // payload: { assignee: { login: 'other-user' } }
+    // expect: runWorkflow NOT called, returns { _tag: 'enqueued' }
+  });
+  it('skips dispatch when dispatchCondition path not found in payload', async () => {
+    // payload: {} (no assignee field)
+    // expect: runWorkflow NOT called (undefined !== 'worktrain-bot')
+  });
+});
+```
+
+**polling-scheduler.test.ts:**
+```typescript
+describe('doPollGitHubQueue adaptive routing', () => {
+  it('always calls dispatchAdaptivePipeline, never dispatch()', async () => {
+    // fake router with dispatchAdaptivePipeline: vi.fn(), dispatch: vi.fn()
+    // expect: dispatchAdaptivePipeline called, dispatch NOT called
+  });
+  it('throws when dispatchAdaptivePipeline is not available on router', async () => {
+    // fake router with ONLY dispatch: vi.fn() (no dispatchAdaptivePipeline)
+    // expect: doPoll throws Error
+    // (runPollCycle catches it and logs warn -- test calls doPoll directly)
+  });
+});
+```
+
+## Risk Register
+
+| Risk | Severity | Mitigation |
+|---|---|---|
+| YAML parser misses dispatchCondition block | Low | Add key case before rawValue === '' check |
+| Strict equals vs coerced comparison (FM5) | Medium | Use extracted === condition.equals |
+| Throw in doPollGitHubQueue not caught | Low | runPollCycle try/catch already in place |
+| Existing queue poll test fakes break | Low | Update makeRouter() to add dispatchAdaptivePipeline |
+| workflowId '' sentinel leaks to delivery | Low | Comment + queue poll never runs route() |
+
+## PR Packaging Strategy
+
+Single PR: `feat/dispatch-condition-and-adaptive-queue`
+All 5 slices in one commit: `feat(trigger): add dispatchCondition filter and route queue triggers through adaptive coordinator`
+
+## Philosophy Alignment Per Slice
+
+| Slice | Principle | Status |
+|---|---|---|
+| types.ts | Immutability by default | Satisfied (readonly fields) |
+| types.ts | Make illegal states unrepresentable | Satisfied (both fields required when block present) |
+| trigger-store.ts | Validate at boundaries | Satisfied (parse-time validation) |
+| trigger-store.ts | Errors are data | Satisfied (returns TriggerStoreError) |
+| trigger-router.ts | Compose with small pure functions | Satisfied (reuse extractDotPath) |
+| trigger-router.ts | Type safety | Satisfied (strict === comparison) |
+| polling-scheduler.ts | Errors are data | Tension (throw instead of Result) -- spec overrides |
+| polling-scheduler.ts | Exhaustiveness | Satisfied (no fallback path) |
+| Tests | Prefer fakes over mocks | Satisfied (fake router with typed methods) |

package/docs/design/dispatch-condition-review-findings.md

@@ -0,0 +1,61 @@
+# Design Review Findings: dispatchCondition and Adaptive Queue
+
+## Tradeoff Review
+
+All four accepted tradeoffs verified as safe:
+1. **Silent skip (`{ _tag: 'enqueued' }`)**: HTTP 202 already sent before route() evaluates. trigger-listener.ts maps enqueued -> 202 unconditionally. Log line provides observability. No breaking change.
+2. **`workflowId: ''` sentinel**: Never forwarded in adaptive dispatch path (only goal/workspace/context passed to dispatchAdaptivePipeline). No delivery path runs for queue poll.
+3. **Throw for missing `dispatchAdaptivePipeline`**: Caught by runPollCycle try/catch (lines 186-196), converted to console.warn. Not a daemon crash.
+4. **YAML sub-object block for `dispatchCondition`**: Handled before the `rawValue === ''` early-skip, following exact `agentConfig` pattern.
+
+## Failure Mode Review
+
+| Failure Mode | Status | Notes |
+|---|---|---|
+| YAML parser misses dispatchCondition block | Handled | Add key case before rawValue === '' check |
+| dispatchCondition on polling trigger | Non-issue | route() never called for polling triggers |
+| workflowId sentinel leaks to delivery | Handled | Delivery only runs from route() path |
+| Throw crashes daemon | Handled | Caught by runPollCycle try/catch |
+| **FM5: Strict equals comparison** | **Requires fix** | Must use `extracted === equals` (strict), not `String(extracted) === equals` |
+
+## Runner-Up / Simpler Alternative Review
+
+- Candidate 2 (optional workflowId): no elements worth borrowing. Blast radius unjustified.
+- Simpler flat-field alternative: rejected -- spec explicitly shows sub-object YAML format.
+- No hybrid improvements beyond FM5 correction.
+
+## Philosophy Alignment
+
+**Satisfied:** Immutability, validate at boundaries, YAGNI, compose with small functions, exhaustiveness.
+
+**Acceptable tensions:**
+- 'Errors as data' vs throw: covered by try/catch in runPollCycle; represents programmer error not domain error.
+- Illegal states vs workflowId sentinel: never read in queue poll dispatch path.
+
+## Findings
+
+### YELLOW: FM5 -- Strict Equals Comparison
+
+The spec says 'strictly equals this string'. The naive implementation might use `String(extractDotPath(...)) === condition.equals` which would cause type coercion (number 42 matches string '42'). Must use strict identity: `extracted === condition.equals`.
+
+**Impact:** Behavioral correctness -- wrong values could trigger dispatch (if payload has numeric field and equals is its string representation).
+
+**Fix:** Implement as `const extracted = extractDotPath(payload, condition.payloadPath); return extracted === condition.equals` (strict identity, no coercion).
+
+### YELLOW: workflowId Sentinel Comment
+
+The `''` sentinel for queue poll `workflowId` is an implicit contract. A comment is needed at the parse site explaining why it's safe.
+
+**Impact:** Maintainability -- future developer may not understand why `''` is accepted.
+
+**Fix:** Add comment: `// workflowId is intentionally '' for github_queue_poll -- the adaptive coordinator determines the pipeline. This field is never used in queue poll dispatch.`
+
+## Recommended Revisions
+
+1. Use `extracted === condition.equals` (not `String(extracted) === condition.equals`) in route()
+2. Add comment at workflowId sentinel assignment in trigger-store.ts
+3. Update existing queue poll test fake in polling-scheduler.test.ts to include `dispatchAdaptivePipeline` method
+
+## Residual Concerns
+
+None blocking. Both findings are Yellow (implementation corrections, not design flaws). The design is sound.