@worca/app 1.0.0 → 1.1.1

package/src/core/graph/seed-templates.mjs

@@ -0,0 +1,318 @@
+// src/core/graph/seed-templates.mjs
+// The 7 hand-written v2 seed templates the V17 migration re-seeds the user's
+// saved pipelines as, plus the static overlay-migration maps.
+//
+// Each entry is a FLAT Template object — `{ id, name, version, domain, createdAt,
+// nodes, wires }` at the TOP level, never nested under `graph`. Flat is
+// load-bearing: validateGraph runs on the whole template and V1 reads `version`
+// off the object it is handed.
+//
+// Shape rules the graphs follow (a copy-check, not an authoring recipe — these
+// were hand-authored and verified against the v1 rows):
+//   - Every template has a Task source node and exactly ONE End node, wired from
+//     `webui.pass` where a webui node exists, else `reviewer.pass`.
+//   - `implementer.done -> reviewer.done`, `reviewer.pass -> checklist.await` and
+//     `checklist.checklist -> webui.checklist` reproduce v1's linear order; refine
+//     self-loops and review loops carry `config.maxCycles: 3`.
+//   - The double-loop templates (wf_full, wf_provided-plan, wf_full-no-decompose)
+//     fan `reviewer.review -> n_or.in1` and `webui.review -> n_or.in2` — each
+//     in-wire keeps its OWN maxCycles, because those are the loop wires and the
+//     gate sites — while `n_or.out -> implementer.fix` carries NO config
+//     (maxCycles on an always-sourced wire fails V13). wf_no-clarify has no or
+//     card: only w10 targets `fix`, and `webui.review` is UNWIRED, matching its
+//     two-feedback v1 row.
+//
+// Parity note: the OR in-wires keep their v1-era wire ids and budgets, so source
+// firings, per-wire delivery counts and gate sites are identical to the direct
+// wire shape; the OR adds one $0 instant exec row per loop emission and forwards
+// the identical review path to `fix`.
+
+import { deepFreeze } from './builtin-workflows.mjs';
+
+/** Full: clarify -> plan -> refine -> decompose -> implement -> review ->
+ *  checklist -> web UI, with both review loops fanned through the or card.
+ *  11 nodes / 17 wires. */
+const WF_FULL = {
+  id: 'wf_full',
+  name: 'Full',
+  version: 2,
+  domain: 'coding',
+  createdAt: '2026-07-29T19:39:27.650Z',
+  nodes: [
+    { id: 'n_task', kind: 'task', x: 60, y: 198, config: {} },
+    { id: 'n_clarify', kind: 'agent', key: 'clarify', x: 360, y: 198, config: {} },
+    { id: 'n_plan', kind: 'agent', key: 'planner', x: 660, y: 198, config: {} },
+    { id: 'n_refine', kind: 'agent', key: 'refiner', x: 960, y: 198, config: {} },
+    { id: 'n_decompose', kind: 'agent', key: 'decomposer', x: 1260, y: 198, config: {} },
+    { id: 'n_impl', kind: 'agent', key: 'implementer', x: 1560, y: 198, config: {} },
+    { id: 'n_review', kind: 'agent', key: 'reviewer', x: 1860, y: 198, config: {} },
+    { id: 'n_check', kind: 'agent', key: 'manualTestsChecklist', x: 2160, y: 198, config: {} },
+    { id: 'n_webui', kind: 'agent', key: 'manualWebUiTesting', x: 2460, y: 198, config: {} },
+    { id: 'n_end', kind: 'end', x: 2760, y: 198, config: {} },
+    { id: 'n_or', kind: 'or', x: 2010, y: 430, config: { arity: 2 } },
+  ],
+  wires: [
+    { id: 'w1', from: { node: 'n_task', port: 'task' }, to: { node: 'n_clarify', port: 'task' } },
+    { id: 'w2', from: { node: 'n_task', port: 'task' }, to: { node: 'n_plan', port: 'task' } },
+    { id: 'w3', from: { node: 'n_clarify', port: 'answers' }, to: { node: 'n_plan', port: 'answers' } },
+    { id: 'w4', from: { node: 'n_plan', port: 'plan' }, to: { node: 'n_refine', port: 'plan' } },
+    { id: 'w5', from: { node: 'n_refine', port: 'revise' }, to: { node: 'n_refine', port: 'revise' }, config: { maxCycles: 3 } },
+    { id: 'w6', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_decompose', port: 'plan' } },
+    { id: 'w7', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_impl', port: 'plan' } },
+    { id: 'w8', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_review', port: 'plan' } },
+    { id: 'w9', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_check', port: 'plan' } },
+    { id: 'w10', from: { node: 'n_decompose', port: 'tasks' }, to: { node: 'n_impl', port: 'task' } },
+    { id: 'w11', from: { node: 'n_impl', port: 'done' }, to: { node: 'n_review', port: 'done' } },
+    { id: 'w12', from: { node: 'n_review', port: 'review' }, to: { node: 'n_or', port: 'in1' }, config: { maxCycles: 3 } },
+    { id: 'w13', from: { node: 'n_review', port: 'pass' }, to: { node: 'n_check', port: 'await' } },
+    { id: 'w14', from: { node: 'n_check', port: 'checklist' }, to: { node: 'n_webui', port: 'checklist' } },
+    { id: 'w15', from: { node: 'n_webui', port: 'review' }, to: { node: 'n_or', port: 'in2' }, config: { maxCycles: 3 } },
+    { id: 'w16', from: { node: 'n_webui', port: 'pass' }, to: { node: 'n_end', port: 'result' } },
+    { id: 'w17', from: { node: 'n_or', port: 'out' }, to: { node: 'n_impl', port: 'fix' } },
+  ],
+};
+
+/** No Clarify: Full minus the clarify node, and with only ONE feedback into
+ *  `fix` — w10 reviewer.review. `webui.review` is deliberately unwired, matching
+ *  the v1 row's two feedbacks. 9 nodes / 13 wires. */
+const WF_NO_CLARIFY = {
+  id: 'wf_no-clarify',
+  name: 'No Clarify',
+  version: 2,
+  domain: 'coding',
+  createdAt: '2026-07-29T19:40:22.212Z',
+  nodes: [
+    { id: 'n_task', kind: 'task', x: 60, y: 198, config: {} },
+    { id: 'n_plan', kind: 'agent', key: 'planner', x: 360, y: 198, config: {} },
+    { id: 'n_refine', kind: 'agent', key: 'refiner', x: 660, y: 198, config: {} },
+    { id: 'n_decompose', kind: 'agent', key: 'decomposer', x: 960, y: 198, config: {} },
+    { id: 'n_impl', kind: 'agent', key: 'implementer', x: 1260, y: 198, config: {} },
+    { id: 'n_review', kind: 'agent', key: 'reviewer', x: 1560, y: 198, config: {} },
+    { id: 'n_check', kind: 'agent', key: 'manualTestsChecklist', x: 1860, y: 198, config: {} },
+    { id: 'n_webui', kind: 'agent', key: 'manualWebUiTesting', x: 2160, y: 198, config: {} },
+    { id: 'n_end', kind: 'end', x: 2460, y: 198, config: {} },
+  ],
+  wires: [
+    { id: 'w1', from: { node: 'n_task', port: 'task' }, to: { node: 'n_plan', port: 'task' } },
+    { id: 'w2', from: { node: 'n_plan', port: 'plan' }, to: { node: 'n_refine', port: 'plan' } },
+    { id: 'w3', from: { node: 'n_refine', port: 'revise' }, to: { node: 'n_refine', port: 'revise' }, config: { maxCycles: 3 } },
+    { id: 'w4', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_decompose', port: 'plan' } },
+    { id: 'w5', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_impl', port: 'plan' } },
+    { id: 'w6', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_review', port: 'plan' } },
+    { id: 'w7', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_check', port: 'plan' } },
+    { id: 'w8', from: { node: 'n_decompose', port: 'tasks' }, to: { node: 'n_impl', port: 'task' } },
+    { id: 'w9', from: { node: 'n_impl', port: 'done' }, to: { node: 'n_review', port: 'done' } },
+    { id: 'w10', from: { node: 'n_review', port: 'review' }, to: { node: 'n_impl', port: 'fix' }, config: { maxCycles: 3 } },
+    { id: 'w11', from: { node: 'n_review', port: 'pass' }, to: { node: 'n_check', port: 'await' } },
+    { id: 'w12', from: { node: 'n_check', port: 'checklist' }, to: { node: 'n_webui', port: 'checklist' } },
+    { id: 'w13', from: { node: 'n_webui', port: 'pass' }, to: { node: 'n_end', port: 'result' } },
+  ],
+};
+
+/** Provided Plan: no planner — the task node carries `planStoreSeed` (A2) and
+ *  wires straight into `refiner.plan`. 9 nodes / 14 wires. */
+const WF_PROVIDED_PLAN = {
+  id: 'wf_provided-plan',
+  name: 'Provided Plan',
+  version: 2,
+  domain: 'coding',
+  createdAt: '2026-08-07T11:29:56.074Z',
+  nodes: [
+    { id: 'n_task', kind: 'task', x: 60, y: 198, config: { planStoreSeed: true } },
+    { id: 'n_refine', kind: 'agent', key: 'refiner', x: 360, y: 198, config: {} },
+    { id: 'n_decompose', kind: 'agent', key: 'decomposer', x: 660, y: 198, config: {} },
+    { id: 'n_impl', kind: 'agent', key: 'implementer', x: 960, y: 198, config: {} },
+    { id: 'n_review', kind: 'agent', key: 'reviewer', x: 1260, y: 198, config: {} },
+    { id: 'n_check', kind: 'agent', key: 'manualTestsChecklist', x: 1560, y: 198, config: {} },
+    { id: 'n_webui', kind: 'agent', key: 'manualWebUiTesting', x: 1860, y: 198, config: {} },
+    { id: 'n_end', kind: 'end', x: 2160, y: 198, config: {} },
+    { id: 'n_or', kind: 'or', x: 1410, y: 430, config: { arity: 2 } },
+  ],
+  wires: [
+    { id: 'w1', from: { node: 'n_task', port: 'task' }, to: { node: 'n_refine', port: 'plan' } },
+    { id: 'w2', from: { node: 'n_refine', port: 'revise' }, to: { node: 'n_refine', port: 'revise' }, config: { maxCycles: 3 } },
+    { id: 'w3', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_decompose', port: 'plan' } },
+    { id: 'w4', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_impl', port: 'plan' } },
+    { id: 'w5', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_review', port: 'plan' } },
+    { id: 'w6', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_check', port: 'plan' } },
+    { id: 'w7', from: { node: 'n_decompose', port: 'tasks' }, to: { node: 'n_impl', port: 'task' } },
+    { id: 'w8', from: { node: 'n_impl', port: 'done' }, to: { node: 'n_review', port: 'done' } },
+    { id: 'w9', from: { node: 'n_review', port: 'review' }, to: { node: 'n_or', port: 'in1' }, config: { maxCycles: 3 } },
+    { id: 'w10', from: { node: 'n_review', port: 'pass' }, to: { node: 'n_check', port: 'await' } },
+    { id: 'w11', from: { node: 'n_check', port: 'checklist' }, to: { node: 'n_webui', port: 'checklist' } },
+    { id: 'w12', from: { node: 'n_webui', port: 'review' }, to: { node: 'n_or', port: 'in2' }, config: { maxCycles: 3 } },
+    { id: 'w13', from: { node: 'n_webui', port: 'pass' }, to: { node: 'n_end', port: 'result' } },
+    { id: 'w14', from: { node: 'n_or', port: 'out' }, to: { node: 'n_impl', port: 'fix' } },
+  ],
+};
+
+/** FULL-NO-Decompose: Full minus the decomposer, so the implementer takes the
+ *  whole plan. 10 nodes / 15 wires. */
+const WF_FULL_NO_DECOMPOSE = {
+  id: 'wf_full-no-decompose',
+  name: 'FULL-NO-Decompose',
+  version: 2,
+  domain: 'coding',
+  createdAt: '2026-08-08T00:02:32.776Z',
+  nodes: [
+    { id: 'n_task', kind: 'task', x: 60, y: 198, config: {} },
+    { id: 'n_clarify', kind: 'agent', key: 'clarify', x: 360, y: 198, config: {} },
+    { id: 'n_plan', kind: 'agent', key: 'planner', x: 660, y: 198, config: {} },
+    { id: 'n_refine', kind: 'agent', key: 'refiner', x: 960, y: 198, config: {} },
+    { id: 'n_impl', kind: 'agent', key: 'implementer', x: 1260, y: 198, config: {} },
+    { id: 'n_review', kind: 'agent', key: 'reviewer', x: 1560, y: 198, config: {} },
+    { id: 'n_check', kind: 'agent', key: 'manualTestsChecklist', x: 1860, y: 198, config: {} },
+    { id: 'n_webui', kind: 'agent', key: 'manualWebUiTesting', x: 2160, y: 198, config: {} },
+    { id: 'n_end', kind: 'end', x: 2460, y: 198, config: {} },
+    { id: 'n_or', kind: 'or', x: 1710, y: 430, config: { arity: 2 } },
+  ],
+  wires: [
+    { id: 'w1', from: { node: 'n_task', port: 'task' }, to: { node: 'n_clarify', port: 'task' } },
+    { id: 'w2', from: { node: 'n_task', port: 'task' }, to: { node: 'n_plan', port: 'task' } },
+    { id: 'w3', from: { node: 'n_clarify', port: 'answers' }, to: { node: 'n_plan', port: 'answers' } },
+    { id: 'w4', from: { node: 'n_plan', port: 'plan' }, to: { node: 'n_refine', port: 'plan' } },
+    { id: 'w5', from: { node: 'n_refine', port: 'revise' }, to: { node: 'n_refine', port: 'revise' }, config: { maxCycles: 3 } },
+    { id: 'w6', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_impl', port: 'plan' } },
+    { id: 'w7', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_review', port: 'plan' } },
+    { id: 'w8', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_check', port: 'plan' } },
+    { id: 'w9', from: { node: 'n_impl', port: 'done' }, to: { node: 'n_review', port: 'done' } },
+    { id: 'w10', from: { node: 'n_review', port: 'review' }, to: { node: 'n_or', port: 'in1' }, config: { maxCycles: 3 } },
+    { id: 'w11', from: { node: 'n_review', port: 'pass' }, to: { node: 'n_check', port: 'await' } },
+    { id: 'w12', from: { node: 'n_check', port: 'checklist' }, to: { node: 'n_webui', port: 'checklist' } },
+    { id: 'w13', from: { node: 'n_webui', port: 'review' }, to: { node: 'n_or', port: 'in2' }, config: { maxCycles: 3 } },
+    { id: 'w14', from: { node: 'n_webui', port: 'pass' }, to: { node: 'n_end', port: 'result' } },
+    { id: 'w15', from: { node: 'n_or', port: 'out' }, to: { node: 'n_impl', port: 'fix' } },
+  ],
+};
+
+/** Quick Fix: plan -> implement -> review, no refiner, no checklist. The
+ *  reviewer's only other input is the VOID `done` port, which is why it stays
+ *  warning-free under V18 (exemption (b)). 5 nodes / 6 wires. */
+const WF_QUICK_FIX = {
+  id: 'wf_quick-fix',
+  name: 'Quick Fix',
+  version: 2,
+  domain: 'coding',
+  createdAt: '2026-08-09T14:40:59.262Z',
+  nodes: [
+    { id: 'n_task', kind: 'task', x: 60, y: 198, config: {} },
+    { id: 'n_plan', kind: 'agent', key: 'planner', x: 360, y: 198, config: {} },
+    { id: 'n_impl', kind: 'agent', key: 'implementer', x: 660, y: 198, config: {} },
+    { id: 'n_review', kind: 'agent', key: 'reviewer', x: 960, y: 198, config: {} },
+    { id: 'n_end', kind: 'end', x: 1260, y: 198, config: {} },
+  ],
+  wires: [
+    { id: 'w1', from: { node: 'n_task', port: 'task' }, to: { node: 'n_plan', port: 'task' } },
+    { id: 'w2', from: { node: 'n_plan', port: 'plan' }, to: { node: 'n_impl', port: 'plan' } },
+    { id: 'w3', from: { node: 'n_plan', port: 'plan' }, to: { node: 'n_review', port: 'plan' } },
+    { id: 'w4', from: { node: 'n_impl', port: 'done' }, to: { node: 'n_review', port: 'done' } },
+    { id: 'w5', from: { node: 'n_review', port: 'review' }, to: { node: 'n_impl', port: 'fix' }, config: { maxCycles: 3 } },
+    { id: 'w6', from: { node: 'n_review', port: 'pass' }, to: { node: 'n_end', port: 'result' } },
+  ],
+};
+
+/** Clarify -> Implement: clarify -> plan -> refine -> implement -> review.
+ *  7 nodes / 10 wires. */
+const WF_CLARIFY_IMPLEMENT = {
+  id: 'wf_clarify-implement',
+  name: 'Clarify -> Implement',
+  version: 2,
+  domain: 'coding',
+  createdAt: '2026-08-09T15:16:43.806Z',
+  nodes: [
+    { id: 'n_task', kind: 'task', x: 60, y: 198, config: {} },
+    { id: 'n_clarify', kind: 'agent', key: 'clarify', x: 360, y: 198, config: {} },
+    { id: 'n_plan', kind: 'agent', key: 'planner', x: 660, y: 198, config: {} },
+    { id: 'n_refine', kind: 'agent', key: 'refiner', x: 960, y: 198, config: {} },
+    { id: 'n_impl', kind: 'agent', key: 'implementer', x: 1260, y: 198, config: {} },
+    { id: 'n_review', kind: 'agent', key: 'reviewer', x: 1560, y: 198, config: {} },
+    { id: 'n_end', kind: 'end', x: 1860, y: 198, config: {} },
+  ],
+  wires: [
+    { id: 'w1', from: { node: 'n_task', port: 'task' }, to: { node: 'n_clarify', port: 'task' } },
+    { id: 'w2', from: { node: 'n_task', port: 'task' }, to: { node: 'n_plan', port: 'task' } },
+    { id: 'w3', from: { node: 'n_clarify', port: 'answers' }, to: { node: 'n_plan', port: 'answers' } },
+    { id: 'w4', from: { node: 'n_plan', port: 'plan' }, to: { node: 'n_refine', port: 'plan' } },
+    { id: 'w5', from: { node: 'n_refine', port: 'revise' }, to: { node: 'n_refine', port: 'revise' }, config: { maxCycles: 3 } },
+    { id: 'w6', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_impl', port: 'plan' } },
+    { id: 'w7', from: { node: 'n_refine', port: 'plan' }, to: { node: 'n_review', port: 'plan' } },
+    { id: 'w8', from: { node: 'n_impl', port: 'done' }, to: { node: 'n_review', port: 'done' } },
+    { id: 'w9', from: { node: 'n_review', port: 'review' }, to: { node: 'n_impl', port: 'fix' }, config: { maxCycles: 3 } },
+    { id: 'w10', from: { node: 'n_review', port: 'pass' }, to: { node: 'n_end', port: 'result' } },
+  ],
+};
+
+/** Clarify -> Quick Fix: Quick Fix with a clarify step in front. 6 nodes /
+ *  8 wires. */
+const WF_CLARIFY_QUICK_FIX = {
+  id: 'wf_clarify-quick-fix',
+  name: 'Clarify -> Quick Fix',
+  version: 2,
+  domain: 'coding',
+  createdAt: '2026-08-09T15:18:40.077Z',
+  nodes: [
+    { id: 'n_task', kind: 'task', x: 60, y: 198, config: {} },
+    { id: 'n_clarify', kind: 'agent', key: 'clarify', x: 360, y: 198, config: {} },
+    { id: 'n_plan', kind: 'agent', key: 'planner', x: 660, y: 198, config: {} },
+    { id: 'n_impl', kind: 'agent', key: 'implementer', x: 960, y: 198, config: {} },
+    { id: 'n_review', kind: 'agent', key: 'reviewer', x: 1260, y: 198, config: {} },
+    { id: 'n_end', kind: 'end', x: 1560, y: 198, config: {} },
+  ],
+  wires: [
+    { id: 'w1', from: { node: 'n_task', port: 'task' }, to: { node: 'n_clarify', port: 'task' } },
+    { id: 'w2', from: { node: 'n_task', port: 'task' }, to: { node: 'n_plan', port: 'task' } },
+    { id: 'w3', from: { node: 'n_clarify', port: 'answers' }, to: { node: 'n_plan', port: 'answers' } },
+    { id: 'w4', from: { node: 'n_plan', port: 'plan' }, to: { node: 'n_impl', port: 'plan' } },
+    { id: 'w5', from: { node: 'n_plan', port: 'plan' }, to: { node: 'n_review', port: 'plan' } },
+    { id: 'w6', from: { node: 'n_impl', port: 'done' }, to: { node: 'n_review', port: 'done' } },
+    { id: 'w7', from: { node: 'n_review', port: 'review' }, to: { node: 'n_impl', port: 'fix' }, config: { maxCycles: 3 } },
+    { id: 'w8', from: { node: 'n_review', port: 'pass' }, to: { node: 'n_end', port: 'result' } },
+  ],
+};
+
+/** The 7 seeds, in seeding order. */
+export const SEED_TEMPLATES = deepFreeze([
+  WF_FULL,
+  WF_NO_CLARIFY,
+  WF_PROVIDED_PLAN,
+  WF_FULL_NO_DECOMPOSE,
+  WF_QUICK_FIX,
+  WF_CLARIFY_IMPLEMENT,
+  WF_CLARIFY_QUICK_FIX,
+]);
+
+/** V17 overlay migration: `config_workflow_nodes.node_id` rewrites, old v1 step
+ *  id -> v2 node id. wf_default is included for projects carrying overlays on
+ *  the builtin default workflow. */
+export const NODE_ID_MAP = deepFreeze({
+  wf_full: { s0_0: 'n_clarify', s1_0: 'n_plan', s2_0: 'n_refine', s3_0: 'n_decompose', s4_0: 'n_impl', s5_0: 'n_review', s6_0: 'n_check', s7_0: 'n_webui' },
+  'wf_no-clarify': { s0_0: 'n_plan', s1_0: 'n_refine', s2_0: 'n_decompose', s3_0: 'n_impl', s4_0: 'n_review', s5_0: 'n_check', s6_0: 'n_webui' },
+  'wf_provided-plan': { s0_0: 'n_refine', s1_0: 'n_decompose', s2_0: 'n_impl', s3_0: 'n_review', s4_0: 'n_check', s5_0: 'n_webui' },
+  'wf_full-no-decompose': { s0_0: 'n_clarify', s1_0: 'n_plan', s2_0: 'n_refine', s3_0: 'n_impl', s4_0: 'n_review', s5_0: 'n_check', s6_0: 'n_webui' },
+  'wf_quick-fix': { s0_0: 'n_plan', s1_0: 'n_impl', s2_0: 'n_review' },
+  'wf_clarify-implement': { s0_0: 'n_clarify', s1_0: 'n_plan', s2_0: 'n_refine', s3_0: 'n_impl', s4_0: 'n_review' },
+  'wf_clarify-quick-fix': { s0_0: 'n_clarify', s1_0: 'n_plan', s2_0: 'n_impl', s3_0: 'n_review' },
+  wf_default: { s_clarify: 'n_clarify', s0_0: 'n_plan', s1_0: 'n_refine', s2_0: 'n_impl', s3_0: 'n_review' },
+});
+
+/** V17 overlay migration: `config_workflow_feedbacks` -> `config_workflow_wires`
+ *  rows, old feedback id -> v2 wire id. Wire ids reflect Amendment f as revised
+ *  (single-wire inputs; the double-loop seeds' blocking wires keep their ids as
+ *  the OR valve's in-wires — exactly where budgets and gates now count, so
+ *  migrated overlays land correctly by construction).
+ *
+ *  wf_no-clarify's fb_0 is the refine self-wire and fb_1 the review loop wire —
+ *  the user's max_cycles=6 overlays ride those two. wf_clarify-implement's fb
+ *  order is BELIEVED swapped in the DB and is UNVERIFIED (that template is absent
+ *  from the reference DB); V17's dynamic resolver, not this row, is what makes
+ *  the migration safe. */
+export const FB_WIRE_MAP = deepFreeze({
+  wf_full: { fb_0: 'w5', fb_1: 'w12', fb_2: 'w15' },
+  'wf_no-clarify': { fb_0: 'w3', fb_1: 'w10' },
+  'wf_provided-plan': { fb_0: 'w2', fb_1: 'w9', fb_2: 'w12' },
+  'wf_full-no-decompose': { fb_0: 'w5', fb_1: 'w10', fb_2: 'w13' },
+  'wf_quick-fix': { fb_0: 'w5' },
+  'wf_clarify-implement': { fb_0: 'w9', fb_1: 'w5' },
+  'wf_clarify-quick-fix': { fb_0: 'w7' },
+  wf_default: { fb_refine: 'w5', fb_review: 'w9' },
+});

package/src/core/model-env.mjs

@@ -20,13 +20,17 @@ export const EFFORTS = ['medium', 'high', 'xhigh', 'max'];
 // Env keys a model entry may NOT set (§4.4): process fundamentals and worca's
 // own runtime knobs, any of which injection could otherwise subvert (mock
 // mode, the claude binary path, the effort flag name). Everything else —
-// including all ANTHROPIC_* / CLAUDE_* — is allowed: routing them is the
+// including all other ANTHROPIC_* / CLAUDE_* — is allowed: routing them is the
 // point. CLAUDE_CODE_SUBPROCESS_ENV_SCRUB is the CLI-2.1.220 permission-mode
 // landmine documented at claude-runner.mjs#buildSpawnEnv.
+// CLAUDE_CODE_SUBAGENT_MODEL is reserved too: the per-node `subagentModel`
+// prompt policy is the only sanctioned wire for a child's model, and a catalog
+// entry silently flooring every fan-out child would contradict the per-node
+// control the UI shows.
 export const RESERVED_MODEL_ENV_KEYS = [
   'PATH', 'HOME', 'TMPDIR', 'SHELL', 'USER', 'LOGNAME', 'TERM',
   'NODE_OPTIONS', 'NODE_EXTRA_CA_CERTS',
-  'CLAUDECODE', 'CLAUDE_CODE_SUBPROCESS_ENV_SCRUB',
+  'CLAUDECODE', 'CLAUDE_CODE_SUBPROCESS_ENV_SCRUB', 'CLAUDE_CODE_SUBAGENT_MODEL',
 ];
 export const RESERVED_MODEL_ENV_PREFIXES = ['WORCA_'];
 
@@ -49,9 +53,12 @@ export function modelEnvRef(value) {
 /**
  * Defensive spawn-time pass over a model entry's env (§4.4): drops reserved
  * keys and non-string values, and expands whole-value ${VAR} refs from
- * `sourceEnv` (an unset or empty var drops the key). Write-time validation
- * already rejects reserved keys, so a drop here means a hand-edited settings
- * file — the caller owns warning about `dropped`.
+ * `sourceEnv` (an unset or empty var drops the key). Values are trimmed and a
+ * value that is empty after trimming drops the key — an ANTHROPIC_MODEL wire id
+ * (#374) reaches `--model` verbatim, so a stray-whitespace or empty value must
+ * not survive. The user catalog rejects reserved keys at write time and plugin
+ * manifests strip them at normalize time, so a drop here means a hand-edited
+ * settings file — the caller owns warning about `dropped`.
  * @param {Record<string,*>|undefined} modelEnv
  * @param {Record<string,string|undefined>} [sourceEnv]
  * @returns {{env: Record<string,string>, dropped: string[]}}
@@ -64,11 +71,108 @@ export function prepareModelEnv(modelEnv, sourceEnv = process.env) {
     const ref = modelEnvRef(v);
     if (ref !== null) {
       const resolved = sourceEnv ? sourceEnv[ref] : undefined;
-      if (resolved === undefined || resolved === '') { dropped.push(k); continue; }
-      env[k] = resolved;
+      const t = typeof resolved === 'string' ? resolved.trim() : '';
+      if (!t) { dropped.push(k); continue; }
+      env[k] = t;
     } else {
-      env[k] = v;
+      const t = v.trim();
+      if (!t) { dropped.push(k); continue; }
+      env[k] = t;
     }
   }
   return { env, dropped };
 }
+
+// ── per-model cost override (opt-in pricing, config.mjs resolveModelCost) ─────
+// Lives HERE for the same reason the env policy does: BOTH catalog layers must
+// validate it against one rule. settings.mjs owns the user's global catalog and
+// plugin-manifest.mjs owns a plugin's models — neither may import the other, and
+// this leaf imports nothing. A plugin that ships a model routed at its own
+// endpoint is exactly the case that needs a price pinned, so its manifest
+// carries `cost` with the same shape and the same validation as a global entry.
+
+/** Allowed per-million-token rate keys for a model's `cost.perMtok` table. */
+export const COST_RATE_KEYS = ['input', 'output', 'cacheRead', 'cacheWrite', 'cacheWrite1h'];
+
+/**
+ * Validate a model `cost` override. Returns the normalized shape or undefined;
+ * THROWS on malformed input (callers that must not throw catch and drop).
+ *   { free: true }                               → recorded spend is always $0
+ *   { perMtok: { input, output, cacheRead, … } } → USD per million tokens, >= 0
+ * `{ free: false }` / `{}` mean "no override" → undefined.
+ * @param {*} cost
+ * @returns {{free:true}|{perMtok:Record<string,number>}|undefined}
+ * @throws {Error}
+ */
+export function assertModelCost(cost) {
+  if (cost === undefined || cost === null) return undefined;
+  if (typeof cost !== 'object' || Array.isArray(cost)) throw new Error('cost must be an object');
+  if (cost.free !== undefined && typeof cost.free !== 'boolean') throw new Error('cost.free must be a boolean');
+  if (cost.free === true) return { free: true };
+  if (cost.perMtok !== undefined) {
+    const p = cost.perMtok;
+    if (!p || typeof p !== 'object' || Array.isArray(p)) {
+      throw new Error('cost.perMtok must be an object of USD-per-million-token rates');
+    }
+    const rates = {};
+    for (const [k, v] of Object.entries(p)) {
+      if (!COST_RATE_KEYS.includes(k)) {
+        throw new Error(`unknown cost.perMtok rate ${JSON.stringify(k)} — allowed: ${COST_RATE_KEYS.join(', ')}`);
+      }
+      const n = Number(v);
+      if (!Number.isFinite(n) || n < 0) throw new Error(`cost.perMtok.${k} must be a finite number >= 0`);
+      rates[k] = n;
+    }
+    if (!Object.keys(rates).length) throw new Error('cost.perMtok must define at least one rate');
+    return { perMtok: rates };
+  }
+  return undefined; // { free: false } or {} — no override
+}
+
+// ── sub-agent model policy (per-node `subagentModel`) ─────────────────────────
+// What a fan-out node's Task/Agent children run on. ONE wire — a prompt block
+// (phases.mjs#subagentModelDirective) that tells the agent to pass `model` on
+// every Task call — because the CLI resolves a child's model as Task-call
+// `model` > the agent definition's own `model:` frontmatter > env default >
+// parent: only the explicit Task-level value reliably binds every child. (The
+// earlier CLAUDE_CODE_SUBAGENT_MODEL env floor was removed for exactly that
+// reason — it bound only agents with no model key — and the key is reserved
+// above so a catalog entry cannot resurrect it.)
+//
+// The vocabulary is deliberately NOT the worca catalog: the CLI's Task tool
+// accepts an ALIAS enum, so a catalog id (or an ANTHROPIC_MODEL wire id) would
+// be rejected at spawn time. Haiku is excluded by product decision.
+export const SUBAGENT_MODELS = ['sonnet', 'opus', 'fable'];
+
+/** "the agent picks per Task call" — a choice rubric in the prompt. */
+export const SUBAGENT_AUTO = 'auto';
+
+/** "children ride the CLI's own resolution" (an agent definition's frontmatter,
+ *  else the parent's model) — the pre-feature prompt. Stored explicitly,
+ *  because the DEFAULT for an unset node is `auto`, not this. */
+export const SUBAGENT_INHERIT = 'inherit';
+
+/** Every storable `subagentModel`. '' / absent are NOT storable — they mean
+ *  "unset", which the runtime resolves to SUBAGENT_DEFAULT. */
+export const SUBAGENT_MODEL_VALUES = [...SUBAGENT_MODELS, SUBAGENT_AUTO, SUBAGENT_INHERIT];
+
+/** What an unset node resolves to at run time: agents choose BY DEFAULT. */
+export const SUBAGENT_DEFAULT = SUBAGENT_AUTO;
+
+/** Whether `v` is a storable subagentModel. */
+export function isSubagentModelValue(v) {
+  return typeof v === 'string' && SUBAGENT_MODEL_VALUES.includes(v);
+}
+
+/** The policy a raw stored value puts in force: a legal value is itself; '' /
+ *  absent / anything that escaped validation is the auto default. */
+export function effectiveSubagentModel(v) {
+  return isSubagentModelValue(v) ? v : SUBAGENT_DEFAULT;
+}
+
+/** The one validation message every writer shares, '' when `v` is acceptable
+ *  ('' and null/undefined mean clear/absent and are always fine). */
+export function subagentModelIssue(v) {
+  if (v == null || v === '' || isSubagentModelValue(v)) return '';
+  return `unknown sub-agent model ${JSON.stringify(String(v))}`;
+}

package/src/core/model-test.mjs

@@ -0,0 +1,79 @@
+// src/core/model-test.mjs
+// One minimal live claude spawn to verify a catalog model actually works —
+// the Models-view Test button (POST /api/models/:id/test). Mirrors the cheap
+// aux-run pattern of title.mjs: the model's catalog routing env travels with
+// the id via resolveModelEnv, no tools, low effort, hard timeout. Never
+// throws — the outcome is a result object either way.
+
+import { runClaude } from './claude-runner.mjs';
+import { resolveModelEnv } from './config.mjs';
+import { classifyError } from './recoverable-error.mjs';
+
+const TEST_TIMEOUT_MS = 60_000;
+const REPLY_CAP = 100;
+
+const SYSTEM = 'You are a connectivity check. Reply with exactly OK.';
+
+/** Actionable hint for a recovery class ('' when there is nothing to add —
+ *  the raw runner message already carries the detail). Pure, for tests. */
+export function hintFor(errorClass) {
+  switch (errorClass) {
+    case 'auth': return 'authentication failed — check the token/secret for this model';
+    case 'network': return 'endpoint unreachable — check ANTHROPIC_BASE_URL';
+    case 'rate_limit': return 'the endpoint is rate-limiting or overloaded — try again shortly';
+    case 'quota': return 'quota/billing problem — check the account behind this endpoint';
+    case 'usage_limit': return 'usage limit reached on the account behind this endpoint';
+    case 'timeout': return `no reply — the test timed out after ${TEST_TIMEOUT_MS / 1000}s`;
+    default: return '';
+  }
+}
+
+/**
+ * Live connectivity check for a catalog model id (global or plugin — the
+ * resolution precedence is resolveModelEnv's). Explicit user action only.
+ * @param {string} id catalog model id
+ * @param {{signal?:AbortSignal, bin?:string, run?:typeof runClaude}} [opts]
+ *   `run` is injectable for unit tests.
+ * @returns {Promise<{ok:true, text:string}|{ok:false, errorClass:(string|null), message:string, hint?:string}>}
+ */
+export async function testModel(id, { signal, bin, run = runClaude } = {}) {
+  const ctrl = new AbortController();
+  const onOuterAbort = () => ctrl.abort();
+  if (signal) {
+    if (signal.aborted) ctrl.abort();
+    else signal.addEventListener('abort', onOuterAbort, { once: true });
+  }
+  const timer = setTimeout(() => ctrl.abort(), TEST_TIMEOUT_MS);
+  timer.unref?.();
+  try {
+    const { text } = await run({
+      cwd: process.cwd(),
+      systemPrompt: SYSTEM,
+      prompt: 'Reply with exactly OK.',
+      model: id,
+      modelEnv: resolveModelEnv(id),
+      effort: 'low',
+      permissionMode: 'acceptEdits',
+      allowedTools: [],          // empty → no --allowedTools flag; pure text gen
+      signal: ctrl.signal,
+      bin,
+      onEvent: () => {},
+    });
+    const reply = String(text || '').split(/\r?\n/).map((l) => l.trim()).find((l) => l) || '';
+    if (!reply) {
+      return { ok: false, errorClass: null, message: 'the model returned an empty reply' };
+    }
+    return { ok: true, text: reply.slice(0, REPLY_CAP) };
+  } catch (err) {
+    if (err && err.name === 'AbortError') {
+      return { ok: false, errorClass: 'timeout', message: `Timed out after ${TEST_TIMEOUT_MS / 1000}s`, hint: hintFor('timeout') };
+    }
+    const message = err && err.message ? err.message : String(err);
+    const errorClass = (err && err.errorClass) || classifyError(message);
+    const hint = hintFor(errorClass);
+    return { ok: false, errorClass, message, ...(hint ? { hint } : {}) };
+  } finally {
+    clearTimeout(timer);
+    if (signal) signal.removeEventListener?.('abort', onOuterAbort);
+  }
+}