@worca/app 1.0.0 → 1.2.0-rc.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/host-guard.mjs

@@ -0,0 +1,271 @@
+// src/core/host-guard.mjs
+// The host-process guard. Every agent worca spawns carries this file as a
+// PreToolUse hook on Bash (see buildSettingsPayload in claude-runner.mjs), so
+// no agent — predefined role, custom agent, plugin agent, or their in-process
+// sub-agents — can kill the worca server that runs it.
+//
+// Born of the 2026-08-31 incident: an implementer cleaning up stray test
+// servers ran `ps aux | grep '[n]ode --disable' | awk '{print $2}' | while
+// read p; do kill $p; done` and took down its own host mid-run (the pattern
+// matches the production server argv exactly).
+//
+// Policy — deny when the command:
+//   - invokes `pkill` or `killall` (pattern kills, unbounded blast radius);
+//   - invokes `kill` with anything but literal numeric PIDs or `%N` jobspecs
+//     (variables, substitutions, piped/xargs input, `-PGID` group targets —
+//     all of these are how a kill reaches processes nobody named);
+//   - names the host PID (WORCA_HOST_PID) as a literal kill target;
+//   - wraps a kill in a nested `sh -c` / `bash -c` payload.
+// Everything else is allowed, so an agent can still stop processes it spawned:
+// look PIDs up first (ps is read-only and always allowed), then kill the
+// literal numbers. Forcing literal PIDs is the point — every literal target
+// passes through the host-PID check.
+//
+// The hook CLI is deliberately fail-open on malformed input: a broken payload
+// must not brick every Bash call of every agent. The DECISION is fail-closed.
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+/** ON unless WORCA_HOST_GUARD is "0"/"false" — the one kill-switch for the
+ *  hook, the WORCA_HOST_PID env var, and the system-prompt preamble alike. */
+export function hostGuardEnabled() {
+  const v = process.env.WORCA_HOST_GUARD;
+  return !(v === '0' || String(v ?? '').toLowerCase() === 'false');
+}
+
+/** The PreToolUse hook entry buildSettingsPayload merges into --settings.
+ *  Runs THIS file with the server's own node; JSON.stringify double-quotes
+ *  both paths for the shell. */
+export function hostGuardHookEntry() {
+  // Forward slashes on purpose: JSON.stringify would double every Windows
+  // backslash and the hook shell's unescaping is unverified there, while
+  // CreateProcess and Git Bash both accept forward-slash paths. POSIX node
+  // paths never contain backslashes, so the replace is a no-op off Windows.
+  const q = (s) => JSON.stringify(String(s).replaceAll('\\', '/'));
+  return {
+    matcher: 'Bash',
+    hooks: [{ type: 'command', command: `${q(process.execPath)} ${q(fileURLToPath(import.meta.url))}` }],
+  };
+}
+
+/** The system-prompt preamble every real spawn carries (runReal prepends it). */
+export function hostGuardSystemPrompt(pid) {
+  return [
+    '## Host process protection',
+    `You run under the worca app server (PID ${pid}, \`node ui/server.mjs\`). Never kill it, and never kill any process you did not spawn yourself.`,
+    'Pattern kills are forbidden and a PreToolUse hook blocks them on every OS: `pkill`, `killall`, `xargs kill`, `taskkill /IM`, `Stop-Process -Name`, `wmic process … delete`, and any `kill` fed from a pipe, variable, or substitution (e.g. `ps aux | grep … | while read p; do kill $p; done`).',
+    'To stop a process you started: record its PID when you spawn it (or list PIDs with `ps`, which is always allowed), then run `kill <literal pid>`.',
+  ].join('\n');
+}
+
+/** Command words that may prefix the one we care about. */
+const SKIP_WORDS = new Set([
+  'do', 'then', 'else', 'elif', 'if', 'while', 'until',
+  'exec', 'command', 'builtin', 'nohup', 'time', 'sudo', 'env',
+]);
+
+const NESTED_SHELLS = new Set(['sh', 'bash', 'zsh', 'dash', 'ksh', 'powershell', 'pwsh', 'cmd']);
+
+/** Any killer, POSIX or Windows, appearing anywhere in a nested-shell payload. */
+const KILLER_WORD_RE = /\b(?:p?kill|killall|taskkill|stop-process|spps|wmic)\b/i;
+
+/** Killers that xargs / find -exec can hand targets to. */
+const KILLER_CMDS = new Set(['kill', 'pkill', 'killall', 'taskkill']);
+const isKillerToken = (t) => KILLER_CMDS.has(basename(t).toLowerCase().replace(/\.exe$/, ''));
+
+/** Replace quoted spans so quoted data ("fix; killall handling") never looks
+ *  like a command, and substitutions so `kill $(…)` / `kill \`…\`` surface as a
+ *  non-literal target instead of vanishing into the segment split; the RAW
+ *  text is still consulted for nested-shell payloads. The `{}` placeholder
+ *  (xargs -I{}, find -exec … {}) becomes a token BEFORE the split eats the
+ *  braces — otherwise `xargs -I{} kill {}` splits into an xargs segment with
+ *  no kill word and a kill segment with no targets, and both pass. */
+function stripQuotes(s) {
+  return s
+    .replace(/'[^']*'/g, ' __q__ ')
+    .replace(/"(?:[^"\\]|\\.)*"/g, ' __q__ ')
+    .replace(/\$\([^()]*\)/g, ' __sub__ ')
+    .replace(/`[^`]*`/g, ' __sub__ ')
+    .replace(/\{\}/g, ' __ph__ ');
+}
+
+const basename = (w) => w.slice(w.lastIndexOf('/') + 1);
+
+/** Leading env assignments and wrapper words stripped off a token list. */
+function commandWord(tokens) {
+  let i = 0;
+  while (i < tokens.length && (SKIP_WORDS.has(tokens[i]) || /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[i]))) i++;
+  return { cmd: basename(tokens[i] ?? ''), rest: tokens.slice(i + 1) };
+}
+
+/** kill's targets: signal options consumed, redirections ignored. */
+function killTargets(rest) {
+  const targets = [];
+  let sawSignal = false;
+  let afterDashDash = false;
+  for (let i = 0; i < rest.length; i++) {
+    const t = rest[i];
+    if (t.startsWith('#')) break;                                  // trailing comment
+    if (/^\d*(?:>>?|<<?|>&|&>>?)$/.test(t)) { i++; continue; }     // spaced redirect: skip its operand too
+    if (/^\d*[<>]/.test(t) || t.includes('>') || t.includes('<')) continue; // attached redirection
+    if (!afterDashDash && t === '--') { afterDashDash = true; continue; }
+    if (!afterDashDash && t.startsWith('-')) {
+      if (t === '-s' || t === '-n') { i++; sawSignal = true; continue; }   // -s TERM / -n 15
+      if (!sawSignal && /^-(?:\d+|[A-Za-z]+\d*)$/.test(t)) { sawSignal = true; continue; } // first -9/-TERM
+      targets.push(t);                                                     // second dash token = a target
+      continue;
+    }
+    targets.push(t);
+  }
+  return targets;
+}
+
+/**
+ * The pure decision. `null` = allow; a non-empty string = deny, with the reason
+ * the agent will read (hook exit 2 feeds stderr back to the model).
+ * @param {string} command   the Bash tool's command text
+ * @param {number} [hostPid] the protected server PID (WORCA_HOST_PID); pattern
+ *   bans apply even without it
+ * @returns {string|null}
+ */
+export function evaluateKillCommand(command, hostPid) {
+  const raw = String(command ?? '');
+  if (!raw.trim()) return null;
+  const pidNote = Number.isFinite(hostPid)
+    ? ` The worca app server (PID ${hostPid}) runs this agent and must survive.`
+    : ' The worca app server runs this agent and must survive.';
+  const advice = ' To stop a process you spawned: list PIDs first (ps is always allowed), then `kill <literal pid>`.';
+
+  const segments = stripQuotes(raw).split(/(?:\|\||&&|;|\||&|\n|\$\(|`|[(){}])+/);
+  for (const seg of segments) {
+    const tokens = seg.trim().split(/\s+/).filter(Boolean);
+    if (!tokens.length) continue;
+    const { cmd: cmdRaw, rest } = commandWord(tokens);
+    // Windows commands are case-insensitive and may carry .exe (`TASKKILL`,
+    // `taskkill.exe`) — normalize once; POSIX names pass through unchanged.
+    const cmd = cmdRaw.toLowerCase().replace(/\.exe$/, '');
+
+    if (cmd === 'pkill' || cmd === 'killall') {
+      return `host guard: blocked \`${cmd}\` — pattern kills are forbidden.${pidNote}${advice}`;
+    }
+    if (cmd === 'xargs' && rest.some(isKillerToken)) {
+      return `host guard: blocked \`xargs kill\` — kill may only take literal numeric PIDs you name yourself.${pidNote}${advice}`;
+    }
+    // find spawns its -exec/-ok payload itself, so the kill never surfaces as
+    // a command word of its own segment; a killer anywhere in find's arguments
+    // alongside an -exec-family flag is the same unbounded fan-out as xargs.
+    if (cmd === 'find'
+        && rest.some((t) => /^-(?:exec|ok)(?:dir)?$/.test(t))
+        && rest.some(isKillerToken)) {
+      return `host guard: blocked \`find -exec kill\` — kill may only take literal numeric PIDs you name yourself.${pidNote}${advice}`;
+    }
+    // A nested shell is suspicious only when it carries an INLINE payload
+    // (-c / /c / -Command); `bash scripts/kill-dev-server.sh` is a script FILE
+    // and stays allowed (deliberate evasion via files is out of the threat
+    // model). PowerShell is the exception: its bare argument IS an inline
+    // command (`powershell "Stop-Process -Name node"`), so it is always scanned.
+    if (NESTED_SHELLS.has(cmd)
+        && (cmd === 'powershell' || cmd === 'pwsh' || rest.some((t) => /^(?:-c|\/c|-command|--command)$/i.test(t)))
+        && KILLER_WORD_RE.test(raw)) {
+      return `host guard: blocked a kill inside a nested \`${cmd}\` invocation — run the kill directly with literal PIDs so it can be checked.${pidNote}${advice}`;
+    }
+
+    // ── Windows-native killers (reachable from Git Bash on Windows) ──────────
+    if (cmd === 'taskkill') {
+      for (let i = 0; i < rest.length; i++) {
+        const flag = rest[i].toLowerCase().replace(/^[/-]+/, '');
+        if (flag === 'im') {
+          return `host guard: blocked \`taskkill /IM\` — killing by image name is a pattern kill.${pidNote}${advice}`;
+        }
+        if (flag === 'pid') {
+          const target = rest[++i] ?? '';
+          if (!/^\d+$/.test(target)) {
+            return `host guard: blocked \`taskkill /PID ${target}\` — only literal numeric PIDs are allowed.${pidNote}${advice}`;
+          }
+          if (Number.isFinite(hostPid) && Number(target) === hostPid) {
+            return `host guard: blocked taskkill of PID ${hostPid} — that is the worca app server this agent runs under. Kill only processes you spawned yourself.`;
+          }
+        }
+      }
+      continue;
+    }
+    if (cmd === 'stop-process' || cmd === 'spps') {
+      let sawId = false;
+      for (let i = 0; i < rest.length; i++) {
+        const t = rest[i].toLowerCase();
+        if (t === '-name' || t.startsWith('-name:')) {
+          return `host guard: blocked \`Stop-Process -Name\` — killing by process name is a pattern kill.${pidNote}${advice}`;
+        }
+        if (t === '-id' || t.startsWith('-id:')) {
+          sawId = true;
+          const value = t.includes(':') ? t.split(':')[1] : (rest[++i] ?? '');
+          for (const part of value.split(',')) {
+            if (!/^\d+$/.test(part)) {
+              return `host guard: blocked \`Stop-Process -Id ${part}\` — only literal numeric PIDs are allowed.${pidNote}${advice}`;
+            }
+            if (Number.isFinite(hostPid) && Number(part) === hostPid) {
+              return `host guard: blocked Stop-Process of PID ${hostPid} — that is the worca app server this agent runs under. Kill only processes you spawned yourself.`;
+            }
+          }
+        }
+      }
+      if (!sawId) {
+        return `host guard: blocked \`Stop-Process\` with no literal -Id — pipeline-fed or bare Stop-Process is a pattern kill.${pidNote}${advice}`;
+      }
+      continue;
+    }
+    if (cmd === 'wmic') {
+      // Checked against the RAW command: a parenthesized WHERE clause splits
+      // the segment (`where (name="node.exe") delete`), hiding the verb from
+      // this segment's tokens. A kill-verb elsewhere in a compound command can
+      // false-positive here — acceptable, the reason explains itself.
+      if (/\bprocess\b/i.test(raw) && /\b(?:delete|terminate)\b/i.test(raw)) {
+        return `host guard: blocked \`wmic process … delete\` — pattern kills are forbidden.${pidNote}${advice}`;
+      }
+      continue; // read-only wmic queries stay allowed
+    }
+
+    if (cmd !== 'kill') continue;
+
+    for (const t of killTargets(rest)) {
+      if (/^\d+$/.test(t)) {
+        if (Number.isFinite(hostPid) && Number(t) === hostPid) {
+          return `host guard: blocked kill of PID ${hostPid} — that is the worca app server this agent runs under. Kill only processes you spawned yourself.`;
+        }
+        continue;
+      }
+      if (/^%\d+$/.test(t)) continue; // this shell's own job
+      if (t.startsWith('-')) {
+        return `host guard: blocked \`kill ${t}\` — process-group/broadcast kills are forbidden.${pidNote}${advice}`;
+      }
+      return `host guard: blocked \`kill ${t}\` — kill accepts only literal numeric PIDs (no variables, substitutions, or piped input).${pidNote}${advice}`;
+    }
+  }
+  return null;
+}
+
+// ── hook CLI ─────────────────────────────────────────────────────────────────
+// stdin: the PreToolUse payload ({ tool_name, tool_input: { command } }).
+// exit 0 = allow; exit 2 = block, stderr is shown to the agent.
+const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain) {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (d) => { raw += d; });
+  process.stdin.on('end', () => {
+    let command = '';
+    try {
+      const payload = JSON.parse(raw);
+      if (payload?.tool_name !== 'Bash') process.exit(0);
+      command = String(payload?.tool_input?.command ?? '');
+    } catch {
+      process.exit(0); // fail-open: a malformed payload must not brick Bash
+    }
+    const pid = Number(process.env.WORCA_HOST_PID);
+    const reason = evaluateKillCommand(command, Number.isFinite(pid) && pid > 0 ? pid : undefined);
+    if (reason) {
+      process.stderr.write(`${reason}\n`);
+      process.exit(2);
+    }
+    process.exit(0);
+  });
+}