@exaudeus/workrail 3.40.0 → 3.42.0

package/docs/design/shaping-workflow-external-research.md

@@ -0,0 +1,119 @@
+# Shaping Workflow: External Research Synthesis
+# Date: Apr 18, 2026
+# Source: Deep research prompt answered by frontier model
+
+## TL;DR
+
+An 11-step prompt chain with two mandatory human gates, a self-refine loop with evaluator-optimizer split, sectioned solution divergence, and a hybrid JSON+markdown artifact. The single highest-leverage design decision: **generation and critique run on structurally different prompts (ideally different model families)** -- anchoring and self-preference bias are not mitigated by CoT or self-reflection alone (Lou & Sun 2025; Panickssery et al. 2024).
+
+## The 11-Step Skeleton
+
+| # | Step | Pattern | Output | Tokens |
+|---|---|---|---|---|
+| 1 | `ingest_and_extract` | Chain | Frame candidates, forces, open questions | 2–5k |
+| 2 | `frame_gate` | Interrupt | Confirmed problem + appetite | small | **MANDATORY HUMAN GATE** |
+| 3 | `diverge_solution_shapes` | Parallel ×4 | 4 candidate rough shapes | med ×4 |
+| 4 | `converge_pick` | Separate judge | Chosen shape + rationale | small-med |
+| 5 | `breadboard_and_elements` | Chain + 1 refine | Breadboard + fat-marker elements | 8–15k |
+| 6 | `rabbit_holes_nogos` | Adversarial | Risks, mitigations, no-gos, assumptions | 3–6k |
+| 7 | `context_pack_build` | Tool-augmented | File globs, utilities, conventions, related PRs | med-large |
+| 8 | `example_map_and_gherkin` | Chain | Rules, examples, Gherkin scenarios | 3–6k |
+| 9 | `draft_pitch` | Self-refine ×2, critic=separate prompt | Full pitch (markdown + JSON) | 8–15k ×critique |
+| 10 | `approval_gate` | Interrupt | Approved pitch | small | **MANDATORY HUMAN GATE** |
+| 11 | `finalize_and_handoff` | Deterministic + schema validate | Canonical artifact + pitch.md | <1k |
+
+Total budget: 50–200k tokens depending on divergence fan-out.
+
+## Key Empirical Findings
+
+### What actually mitigates LLM failure modes in shaping (ranked):
+1. **Generator ≠ Evaluator with authorship obfuscation** -- use different model families for generation vs critique. Beats anchoring, self-preference, and mode collapse simultaneously. CoT and self-reflection alone do NOT work (Lou & Sun 2025).
+2. **Verbalized Sampling + N-alternatives-before-selection** -- prompt for a distribution, not a single answer. 1.6–2.1× diversity gain (Zhang et al. arXiv 2510.01171).
+3. **Schema-constrained structured output** -- kills verbosity compensation, forces right abstraction level by construction.
+4. **ClarifyGPT-style consistency check** -- generate two independent interpretations; divergence triggers clarification.
+5. **Self-Refine with specific rubric**, bounded at 2–3 iterations (~20% absolute gain, Madaan et al. arXiv 2303.17651).
+6. **Red-team pass** with explicit "what's hallucinated / what's missing" prompts against a separate instance.
+
+### The right level of abstraction (encodable heuristic)
+**Interfaces and Invariants, Not Function Bodies.**
+
+Classify every sentence in the pitch as:
+- **(a) Interface** -- user-visible surfaces, data objects, integration points, touched modules
+- **(b) Invariant** -- declarative constraints (idempotency, auth model, consistency requirements, latency budgets)
+- **(c) Exclusion** -- explicitly excluded functionality
+- **(d) Implementation detail** -- over-specification, demote or cut
+- **(e) Vague** -- under-specification, replace with concrete interface/invariant or ask clarifying question
+
+A well-shaped pitch contains only (a), (b), (c).
+
+### Shaping for AI implementers vs humans (the key asymmetry)
+LLM implementers need:
+- **MORE explicit** than any human spec on: interfaces, invariants, conventions, no-gos, exact API versions, file boundaries (LLMs fabricate APIs, lack tacit codebase knowledge, lack scope-shame)
+- **LESS explicit** than junior-human spec on: standard implementation patterns (CRUD, routing, idiomatic error handling -- LLMs know these better)
+
+The dominant failure mode to design against: **confident architectural divergence** -- agent produces working, tested, reviewable PR that reinvents an existing utility or lands logic in the wrong layer. Looks plausible in review. Neither tests nor LLM sensors reliably catch it. Only a better spec prevents it.
+
+### Context Pack (Step 7) is the highest-leverage AI-specific addition
+But: **LLM-generated Context Packs are measurably inferior to human-curated ones** (ETH Zurich AGENTS.md study -- LLM-generated context reduced task success in 5 of 8 settings). Treat Step 7 output as a draft requiring spot-check.
+
+## The Artifact Schema
+
+```jsonc
+{
+  "shaping_run_id": "uuid",
+  "frame": {
+    "problem_story_md": "...",
+    "appetite": {
+      "calendar_weeks": 6,
+      "token_budget_est": 120000,
+      "agent_turns_est": 60,
+      "files_touched_est": 8,
+      "sizing_bucket": "small|medium|large"
+    },
+    "forces": { "push": [...], "pull": [...], "anxiety": [...], "habit": [...] }
+  },
+  "solution": {
+    "breadboard_md": "...",
+    "elements": [{ "name": "...", "description_md": "...", "classification": "interface|invariant|exclusion" }],
+    "alternatives_considered": [{ "sketch": "...", "rejected_because": "..." }]
+  },
+  "context_pack": {
+    "touch_globs": ["src/billing/**"],
+    "do_not_touch_globs": ["src/auth/**", "migrations/**"],
+    "reuse_utilities": [{ "path": "...", "symbol": "...", "signature": "...", "reason_to_reuse": "..." }],
+    "conventions_md": "...",
+    "related_prior_art": [{ "path_or_pr": "...", "relevance": "..." }]
+  },
+  "acceptance_criteria": {
+    "gherkin": "Feature: ...\n  Scenario: ...",
+    "verification_commands": ["pnpm test src/billing", "tsc --noEmit"],
+    "example_map": { "rules": [...], "examples": [...], "open_questions": [...] }
+  },
+  "rabbit_holes": [{ "risk": "...", "severity": "low|med|critical", "mitigation": "...", "patch_applied": true }],
+  "no_gos": ["..."],
+  "assumptions_log": [{ "step": "...", "assumption": "...", "confidence": 0.7, "rationale": "..." }],
+  "decomposition": {
+    "walking_skeleton": { "description": "thin end-to-end slice", "files": [...] },
+    "atomic_subtasks": [{ "id": "s1", "title": "...", "depends_on": [], "est_context_window": "single", "acceptance_scenario_refs": ["scenario-1"] }]
+  },
+  "pitch_md": "# Pitch: ...\n\n## Problem\n...",
+  "build_readiness_score": { "rubric_pass_count": 5, "critical_blockers": 0 }
+}
+```
+
+## What NOT to Build
+- Do NOT make this a dynamic autonomous agent -- shaping has a known skeleton (workflow, not agent)
+- Do NOT use tree-of-thoughts -- no cheap partial-goal verification signal in shaping
+- Do NOT build multi-agent role-plays -- single-voice judge with sectioning strictly dominates
+- Do NOT skip the frame gate on "small" tasks -- wrong frame on a small task still wastes the run
+
+## Failure Modes and Mitigations
+
+| Failure mode | Mitigation |
+|---|---|
+| Mode collapse on diverge step | Verbalized Sampling framing, explicit framing diversity, auto-retry at higher temperature if >70% overlap |
+| Self-preference on judge | Obfuscate authorship by rewriting all candidates into uniform voice; ideally different model family |
+| Verbosity compensation on pitch | Hard max-length on JSON fields; critic checks for vague modifiers without concrete nouns |
+| Hallucinated Context Pack entries | Tool-augment Step 7 with repo grep/AST scan; schema-validate all paths before Step 10 |
+| Over-decomposition | Minimum subtask size = single context window; maximum 8 subtasks per pitch; if more, appetite was wrong |
+| Silent architectural divergence | Include consistency-check sub-task: implementer lists every new file/symbol and justifies why it's not a duplicate |

package/docs/discovery/late-bound-goals-impl-plan.md

@@ -0,0 +1,147 @@
+# Implementation Plan: Late-Bound Goals
+
+**Feature**: Default `goalTemplate: "{{$.goal}}"` when no `goal` and no `goalTemplate` configured.
+
+---
+
+## Problem Statement
+
+Triggers require a static `goal` in `triggers.yml`. This makes dynamic-goal use cases (PR review, incident response) require either a static placeholder goal or a custom `goalTemplate`. The feature enables: `curl -X POST /webhook/my-trigger -d '{"goal": "review PR #42"}'` without any goal pre-configuration.
+
+---
+
+## Acceptance Criteria
+
+1. A trigger with neither `goal` nor `goalTemplate` in `triggers.yml` loads successfully (no `missing_field` error).
+2. When the webhook payload contains a `goal` field, the session is started with that value as the goal.
+3. When the webhook payload has no `goal` field, the session is started with `'Autonomous task'` as the goal, AND a warning is logged to daemon stderr.
+4. Existing triggers with a static `goal` field behave identically to before.
+5. TypeScript compiles without errors (no new `any` or `!` assertions on the new code path).
+
+---
+
+## Non-Goals
+
+- No change to `TriggerDefinition` type (`goal: string` stays required).
+- No change to `trigger-router.ts` interpolation logic.
+- No change to `console-routes.ts` dispatch endpoint.
+- No `goalSource` discriminant on `TriggerDefinition` (future enhancement).
+- No configurable fallback string other than `'Autonomous task'`.
+
+---
+
+## Philosophy-Driven Constraints
+
+- Validate at boundaries: injection must happen in `trigger-store.ts`, not in `trigger-router.ts`.
+- Make illegal states unrepresentable: `TriggerDefinition.goal` must always be a valid `string`.
+- YAGNI: minimal change -- named constant + ~8 lines + tests.
+- Document why: WHY comment required above the injection block.
+
+---
+
+## Invariants
+
+1. `TriggerDefinition.goal: string` -- never `undefined` or empty string after parse.
+2. `trigger.goal` is only used as a display/fallback value, never as a routing key.
+3. The interpolated goal (from payload or fallback) flows to the session, not the sentinel.
+4. Injection only fires when both `raw.goal` and `raw.goalTemplate` are absent.
+
+---
+
+## Selected Approach
+
+**Candidate A: Parse-time sentinel injection in `validateAndResolveTrigger()`**
+
+1. Remove `'goal'` from `requiredStringFields`.
+2. After the required-fields loop, add a block:
+   - If `raw.goal` absent AND `raw.goalTemplate` absent: set `resolvedGoal = LATE_BOUND_GOAL_SENTINEL` and `resolvedGoalTemplate = '{{$.goal}}'`. Log an INFO message.
+   - If `raw.goal` absent AND `raw.goalTemplate` present: set `resolvedGoal = LATE_BOUND_GOAL_SENTINEL`.
+   - Otherwise: `resolvedGoal = raw.goal!.trim()`.
+3. Replace `goal: raw.goal!.trim()` on line 974 with `goal: resolvedGoal`.
+4. If `resolvedGoalTemplate` was injected, pass it via the `goalTemplate` spread at line 980.
+
+**Runner-up**: Candidate B (optional type) -- rejected because it cascades null checks to 3+ files.
+
+**Rationale**: Exact match to the `concurrencyMode` default pattern at line 756. Zero downstream impact.
+
+---
+
+## Vertical Slices
+
+### Slice 1: Core implementation (~8 lines in trigger-store.ts)
+
+**File**: `src/trigger/trigger-store.ts`
+
+**Changes**:
+- Add `const LATE_BOUND_GOAL_SENTINEL = 'Autonomous task';` near the top of the validation section.
+- Remove `'goal'` from `requiredStringFields` array.
+- Add injection block with WHY comment + INFO log.
+- Declare `let resolvedGoal: string;` and `let resolvedGoalTemplate: string | undefined;` before the injection block.
+- Replace `goal: raw.goal!.trim()` with `goal: resolvedGoal` in the TriggerDefinition literal.
+- Pass `resolvedGoalTemplate` to the `goalTemplate` spread.
+
+**Done when**: TypeScript compiles. `loadTriggerConfig` returns a valid `TriggerDefinition` for a YAML with no `goal` and no `goalTemplate`.
+
+### Slice 2: Tests for trigger-store.ts
+
+**File**: `tests/unit/trigger-store.test.ts`
+
+**New test cases**:
+1. Trigger with no `goal` and no `goalTemplate` loads successfully, has `goal = 'Autonomous task'` and `goalTemplate = '{{$.goal}}'`.
+2. Trigger with no `goal` but an explicit `goalTemplate` loads successfully, has `goal = 'Autonomous task'` and the specified `goalTemplate`.
+3. Trigger with a static `goal` behaves identically to before (regression).
+
+**Done when**: All 3 tests pass.
+
+### Slice 3: Test for trigger-router.ts integration
+
+**File**: `tests/unit/trigger-router.test.ts`
+
+**New test case**:
+1. Route a webhook event with payload `{ goal: 'review PR #42' }` to a late-bound trigger. Verify `runWorkflow` is called with `goal = 'review PR #42'`.
+2. Route a webhook event with no `goal` field to a late-bound trigger. Verify `runWorkflow` is called with `goal = 'Autonomous task'`.
+
+**Done when**: Both tests pass.
+
+---
+
+## Test Design
+
+All tests use the existing `loadTriggerConfig` (pure function, no I/O) and `TriggerRouter` patterns from the test files. No mocks needed for Slice 2. Slice 3 uses `makeFakeRunWorkflow` pattern already in the test file.
+
+Run: `npx vitest run tests/unit/trigger-store.test.ts tests/unit/trigger-router.test.ts`
+
+---
+
+## Risk Register
+
+| Risk | Likelihood | Impact | Mitigation |
+|---|---|---|---|
+| Non-null assertion on line 974 missed | Low | Compile error | TypeScript will catch |
+| Slice 3 test fails due to goal not threading through | Low | Test failure | Trace through route() logic |
+| Existing trigger-store tests broken by goal no longer being required | Low | Test failure | Regression test in Slice 2 covers this |
+
+---
+
+## PR Packaging
+
+Single PR: `feat/late-bound-goals`. All 3 slices in one commit. ~20-30 lines total (source + tests).
+
+---
+
+## Philosophy Alignment
+
+- validate-at-boundaries -> satisfied (injection in trigger-store.ts)
+- make-illegal-states-unrepresentable -> satisfied (goal: string always holds)
+- YAGNI -> satisfied (~8 source lines)
+- document-why -> satisfied (WHY comment in injection block)
+- prefer-explicit-domain-types -> tension (sentinel is stringly-typed; acceptable -- future `goalSource` discriminant tracked)
+
+---
+
+## Plan Confidence
+
+- unresolvedUnknownCount: 0
+- planConfidenceBand: High
+- estimatedPRCount: 1
+- followUpTickets: "Add goalSource discriminant to TriggerDefinition for console UI enhancement"

package/docs/discovery/late-bound-goals-review.md

@@ -0,0 +1,82 @@
+# Design Review Findings: Late-Bound Goals
+
+**Feature**: Default `goalTemplate: "{{$.goal}}"` when no static `goal` and no `goalTemplate` is configured.  
+**Design**: Candidate A -- parse-time sentinel injection in `validateAndResolveTrigger()`.
+
+---
+
+## Tradeoff Review
+
+| Tradeoff | Conditions for failure | Status |
+|---|---|---|
+| Synthetic sentinel `'Autonomous task'` in `goal` field | If `trigger.goal` were used for routing/dedup (not display only). Verified: only used in `interpolateGoalTemplate` fallback and logs. | Acceptable |
+| No `console.warn` on load for late-bound triggers | Operators may not discover this feature. Mitigated by adding a `console.log` at daemon startup when injection fires. | Acceptable with INFO log |
+| Sentinel shows in console trigger list | Cosmetic only. Sessions get the interpolated goal from payload, not the sentinel. | Acceptable |
+
+---
+
+## Failure Mode Review
+
+| Failure Mode | Handled? | Missing Mitigation | Risk |
+|---|---|---|---|
+| Console UI shows 'Autonomous task' | Yes -- cosmetic, not functional | Future: show `goalTemplate` in trigger list | Low |
+| Payload has no `goal` field | Yes -- `interpolateGoalTemplate` already warns (line 127) | None needed | Low |
+| Non-null assertion `raw.goal!.trim()` panics | Handled by replacing with `resolvedGoal: string` | TypeScript compile-time check | Low |
+| `goalTemplate`-only trigger with no `goal` | Handled -- inject sentinel for this case too | None needed | Low |
+
+No high-risk failure modes.
+
+---
+
+## Runner-Up / Simpler Alternative Review
+
+- **Candidate B** (optional type): nothing worth borrowing. Cascades null checks to 3+ files.
+- **Simpler variant** (only inject when both absent, skip goalTemplate-only case): does NOT satisfy acceptance criteria -- existing triggers using only `goalTemplate` would still fail with `missing_field`.
+- **Hybrid improvement**: extract `'Autonomous task'` to a named constant `LATE_BOUND_GOAL_SENTINEL` for searchability. Low cost, worth including.
+
+---
+
+## Philosophy Alignment
+
+**Satisfied**: validate-at-boundaries, make-illegal-states-unrepresentable, immutability, YAGNI, determinism.
+
+**Under tension**: prefer-explicit-domain-types -- a `goalSource` discriminant would be more type-honest. Acceptable: documented as a future enhancement, not blocking this fix.
+
+---
+
+## Findings
+
+### Yellow: Named constant for sentinel
+
+**Severity**: Yellow (code quality, not correctness)  
+**Finding**: `'Autonomous task'` hardcoded inline is harder to search and understand than a named constant.  
+**Fix**: `const LATE_BOUND_GOAL_SENTINEL = 'Autonomous task';` at module scope.
+
+### Yellow: Missing INFO log at injection time
+
+**Severity**: Yellow (operator experience)  
+**Finding**: Operators who configure a trigger without `goal`/`goalTemplate` get silent late-bound behavior. A `console.log` at injection time helps discoverability.  
+**Fix**: `console.log('[TriggerStore] Trigger "%s" has no static goal or goalTemplate -- defaulting to goalTemplate: "{{$.goal}}" (goal from payload)', rawId);`
+
+### Yellow: Missing WHY comment in code
+
+**Severity**: Yellow (maintainability)  
+**Finding**: The injection block needs a comment explaining the late-bound goal contract and the sentinel value.
+
+No Red or Orange findings.
+
+---
+
+## Recommended Revisions
+
+1. Extract sentinel to named constant: `const LATE_BOUND_GOAL_SENTINEL = 'Autonomous task';`
+2. Add `console.log` when injecting the default.
+3. Add WHY comment above the injection block.
+4. Update `docs/discovery/late-bound-goals.md` with these minor additions.
+
+---
+
+## Residual Concerns
+
+1. **Console UI display**: Late-bound triggers show 'Autonomous task' in the trigger list until a UI enhancement adds `goalTemplate` as a separate display field. Documented as a known limitation, not a bug.
+2. **Future discriminant**: A `goalSource: 'static' | 'payload'` field on `TriggerDefinition` would be the cleaner long-term design. Filed in backlog. This change does not block it.

package/docs/discovery/late-bound-goals.md

@@ -0,0 +1,118 @@
+# Design Candidates: Late-Bound Goals
+
+**Feature**: Default `goalTemplate: "{{$.goal}}"` when no static `goal` and no `goalTemplate` is configured, enabling dynamic goals from the webhook payload.
+
+**Date**: 2026-04-18
+
+---
+
+## Problem Understanding
+
+### Core Tensions
+
+1. **Type safety vs relaxed validation**: `TriggerDefinition.goal: string` is a required field by type. Relaxing the YAML validation (allowing `goal` to be absent) must not violate the type. Resolved by injecting a sentinel.
+
+2. **Parse-time vs dispatch-time defaulting**: Injecting at parse time (trigger-store.ts) keeps the router clean. Injecting at dispatch time (trigger-router.ts) would require making `goal` optional in the type or adding defensive null checks everywhere `trigger.goal` is used.
+
+3. **Sentinel vs empty string**: The fallback goal for "payload had no goal field" must be human-readable in logs and the console UI. `'Autonomous task'` is the minimum useful value.
+
+4. **Backward compat**: Existing triggers in `triggers.yml` have a static `goal`. The change must be zero-impact for them.
+
+### Likely Seam
+
+`validateAndResolveTrigger()` in `src/trigger/trigger-store.ts` -- specifically between the `requiredStringFields` check (line 553) and the `goalTemplate` assembly (line 654). The new logic fits naturally there: after required non-goal fields are checked, handle the `goal`/`goalTemplate` pair together.
+
+### What Makes It Hard
+
+Technically simple, but the non-null assertion `goal: raw.goal!.trim()` on line 974 would panic if `goal` is removed from `requiredStringFields` without also ensuring injection. A junior developer might instead make `goal` optional in `TriggerDefinition`, cascading null checks across all consumers.
+
+---
+
+## Philosophy Constraints
+
+- **Validate at boundaries, trust inside** (CLAUDE.md): inject the default at parse time in trigger-store.ts, not at dispatch time in trigger-router.ts.
+- **Make illegal states unrepresentable** (CLAUDE.md): `TriggerDefinition.goal` must always be a valid `string`. Sentinel injection preserves this.
+- **YAGNI with discipline** (CLAUDE.md): `'Autonomous task'` is the minimum viable fallback. Do not add configurable fallback strings.
+- **Repo pattern** (trigger-store.ts line 756): `concurrencyMode` defaults to `'serial'` at parse time -- exactly the pattern to follow.
+
+No philosophy conflicts detected.
+
+---
+
+## Impact Surface
+
+- `src/trigger/trigger-store.ts` line 553: `goal` removed from `requiredStringFields`
+- `src/trigger/trigger-store.ts` line 974: `goal: raw.goal!.trim()` must become `goal: resolvedGoal`
+- `src/trigger/trigger-router.ts`: no change -- `interpolateGoalTemplate` already handles `{{$.goal}}` and falls back to `staticGoal`
+- `src/trigger/types.ts`: no change -- `goal: string` stays required
+- `src/v2/usecases/console-routes.ts` line 677: returns `t.goal` in trigger list -- will show `'Autonomous task'` for late-bound triggers (acceptable UX)
+- `tests/unit/trigger-store.test.ts`: add 2-3 new test cases
+- `tests/unit/trigger-router.test.ts`: add 1 test for `{{$.goal}}` dispatch
+
+---
+
+## Candidates
+
+### Candidate A: Parse-time sentinel injection (recommended)
+
+**Summary**: Remove `goal` from `requiredStringFields`. After the required checks, add a block: if `raw.goal` absent AND `raw.goalTemplate` absent, set `resolvedGoal = 'Autonomous task'` and inject `goalTemplate = '{{$.goal}}'`; if `raw.goal` absent AND `raw.goalTemplate` present, set `resolvedGoal = 'Autonomous task'`; otherwise use `raw.goal.trim()`. Replace `raw.goal!.trim()` on line 974 with `resolvedGoal`.
+
+- **Tensions resolved**: type safety (sentinel ensures `string`), backward compat, parse-time defaulting
+- **Tension accepted**: sentinel is synthetic -- `'Autonomous task'` shows in console for unconfigured triggers
+- **Boundary**: `validateAndResolveTrigger()` in trigger-store.ts -- the correct validation boundary
+- **Why this boundary**: all other defaults (`concurrencyMode`, `referenceUrls`, `agentConfig`) are applied here, not in the router
+- **Failure mode**: operators reading the console trigger list see `'Autonomous task'` as the goal for late-bound triggers; acceptable since the real goal comes from the payload
+- **Repo pattern**: follows `concurrencyMode` default exactly
+- **Gains**: ~8 lines changed, zero downstream changes, fully backward-compatible
+- **Losses**: nothing material
+- **Scope**: best-fit
+- **Philosophy**: honors validate-at-boundaries, make-illegal-states-unrepresentable, YAGNI
+
+### Candidate B: Make `goal` optional in TriggerDefinition
+
+**Summary**: Change `readonly goal: string` to `readonly goal?: string` in `TriggerDefinition`. Remove `goal` from `requiredStringFields`. Update trigger-router.ts and console-routes.ts to handle `goal | undefined`.
+
+- **Tensions resolved**: type honesty -- `goal` really is absent for late-bound triggers
+- **Tensions accepted**: type change cascades -- every consumer of `trigger.goal` must handle `undefined`
+- **Boundary**: types.ts (type contract) + all consumers
+- **Failure mode**: cascading null checks; `trigger.goal ?? ''` as the router fallback is worse UX than `'Autonomous task'`
+- **Repo pattern**: departs from existing pattern where all `TriggerDefinition` fields are either required or explicitly optional
+- **Gains**: type honesty
+- **Losses**: type safety guarantee; cascading changes across router, console-routes, tests
+- **Scope**: too broad -- type change touches 3+ files unnecessarily
+- **Philosophy**: conflicts with make-illegal-states-unrepresentable, YAGNI
+
+---
+
+## Comparison and Recommendation
+
+| Dimension | Candidate A | Candidate B |
+|---|---|---|
+| Type safety | Full -- `goal: string` always holds | Weakened -- `goal?: string` propagates |
+| Files changed | 1 source + tests | 3+ source files + tests |
+| Backward compat | 100% | 100% but requires null guards |
+| Repo pattern fit | Exact (concurrencyMode) | Departs from established pattern |
+| Reversibility | Trivial | Requires re-tightening type across consumers |
+
+**Recommendation: Candidate A.** Resolves all tensions at the correct boundary with the minimum change surface. Exact match to the established `concurrencyMode` default pattern. Zero downstream impact.
+
+---
+
+## Self-Critique
+
+**Strongest counter-argument**: Candidate B is more type-honest. The sentinel `'Autonomous task'` is a lie -- the goal is really absent at config time. Operators reading the console trigger list may be confused.
+
+**Why it still loses**: The console trigger list already shows `goalTemplate` as a separate field (if set). For late-bound triggers, the UI can be enhanced later to show `goalTemplate` instead of `goal` -- but that is a separate concern. The type lie is contained to display; routing behavior is correct.
+
+**Narrower option**: Only inject `goalTemplate` without a sentinel `goal`, using a conditional on the object literal. But `TriggerDefinition.goal: string` is required, so this path leads back to Candidate B (type change required).
+
+**Broader option**: Add `goalSource: 'static' | 'template' | 'payload'` discriminant to `TriggerDefinition` for explicit tracking. Useful for a future console UI enhancement, but out of scope for this 10-line fix.
+
+**Invalidating assumption**: If `trigger.goal` is used anywhere to make routing decisions (not just as a display value or fallback), the sentinel could cause incorrect behavior. Verified: `trigger.goal` is only used in `interpolateGoalTemplate` as the `staticGoal` fallback and in log messages. Safe.
+
+---
+
+## Open Questions for the Main Agent
+
+1. Should the sentinel string be `'Autonomous task'` or something else (e.g. `'No goal configured'`, `'(goal from payload)'`)? The backlog does not specify. `'Autonomous task'` matches the product language used elsewhere.
+2. Should a `console.warn` be emitted when both `goal` and `goalTemplate` are absent, so operators know the trigger is using late-bound goals? This would help debugging misconfigured triggers.