Epic: Work Graph — explicit task-DAG orchestration (graph engineering)

[rdfitted]

Why

hive-manager has exactly one formal graph (the Knowledge Atlas — typed edges, degrees, force layout, tests) while work and agent orchestration is a tree plus a flat queue: PlanTask has no depends_on, the run queue is FIFO-with-lease, blocking is workers polling a markdown ## Status: line, sequencing is "Phase 1/2/3" prose interpreted by the LLM, and TaskGraph has been a TODO placeholder at src-tauri/src/orchestrator/planner.rs:15 since the module was stubbed.

This epic makes the work graph real. The plan artifact becomes a typed graph the Master Planner emits and the scheduler enforces; review becomes structure instead of discipline; and the two knowledge systems we already run (per-repo .ai-docs/ project DNA + the institutional wiki) plus the deterministic code graph (/codegraph) feed the work graph as first-class inputs.

Reference framing: org graph (stable roles) vs work graph (ephemeral per-session task DAG). Templates are institutional; instances are ephemeral and archived.

Architecture invariants (apply to every child issue)

1. Provenance is a first-class edge attribute from the first schema draft: planner | codegraph | knowledge | runtime. Never mix classes in a way consumers can't distinguish.
2. Anti-hub guardrail: no node may be linked from a high fraction of all nodes. Context/gotcha nodes attach by scope-intersection, never broadcast.
3. The graph never grades its own homework: effectiveness verdicts come from a separate evaluator (feat(retro): post-run graph retro — independent evaluator, topology-effectiveness metrics, learnings output #217), land as unreviewed learnings, and are graded by the existing curation pipeline.
4. Knowledge nodes are derived views: sourced from .ai-docs/ + wiki at instantiation, rebuildable, no write-back from the work graph.
5. Backward compatible: a plan with no dependency edges behaves exactly like today (all tasks immediately ready).

Children

Phase 1 — substrate (strictly ordered)

• feat(orchestrator): work-graph schema — typed nodes, edges, contracts, provenance classes #210 work-graph schema — typed nodes, edges, contracts, provenance classes
• feat(planner): Master Planner emits the work graph + PlanReady validation gate #211 Master Planner emits the work graph + PlanReady validation gate
• feat(queue): readiness-gated claiming — predecessors-Finalized replaces FIFO + STANDBY polling #212 readiness-gated claiming — predecessors-Finalized replaces FIFO + STANDBY polling

Phase 2 — governance + evidence (parallel after #210)

• feat(review): review as templated subgraphs — multi-lens review nodes, Judge/Prince as standard structure #213 review as templated subgraphs — multi-lens review, Judge/Prince structure, opt-in checkpoint waves
• feat(orchestrator): record the runtime graph — plan-vs-actual divergence + instance archival #214 record the runtime graph — plan-vs-actual divergence + instance archival

Phase 3 — knowledge interlock

• feat(planner): codegraph integration — touches edges, repo-shape facts, parallel-conflict detection #215 codegraph integration — touches edges, repo-shape facts, parallel-conflict detection
• feat(templates): graph templates — institutional archetypes + per-repo overrides, instantiation pipeline #216 graph templates — institutional archetypes + per-repo overrides, instantiation pipeline
• feat(context): gotcha/context nodes — derived-view informs edges from .ai-docs, scope-intersection attachment #218 gotcha/context nodes — derived-view informs edges, scope-intersection attachment

Phase 4 — the compound loop

• feat(retro): post-run graph retro — independent evaluator, topology-effectiveness metrics, learnings output #217 post-run graph retro — independent evaluator, topology-effectiveness metrics, learnings output

Supporting (schedule opportunistically)

• chore(session): lift SessionState transitions into a queryable transition table #219 SessionState transition table (independent, cheap)
• feat(observability): every session serves its work graph — read API + always-on visibility as a standing invariant #227 every session serves its work graph — read API + always-on lifecycle guarantee (standing invariant; prerequisite for feat(ui): work-graph view — reuse the Knowledge Atlas force renderer for the task DAG #220)
• feat(ui): work-graph view — reuse the Knowledge Atlas force renderer for the task DAG #220 work-graph view reusing the Knowledge Atlas force renderer (consumes feat(observability): every session serves its work graph — read API + always-on visibility as a standing invariant #227)

Dependency graph

#210 schema ──► #211 planner emission ──► #212 readiness-gated queue
   │                                          │
   ├──► #213 review subgraphs                 │
   ├──► #214 runtime recording ───────────────┼──► #217 retro
   │        │                                 │      ▲
   │        └──► #227 API ──► #220 viz     │      │
   │                                          ▼      │
   └──► #218 gotcha nodes ◄── #215 codegraph ──► #216 templates
                (touches)        (repo shape)  (lineage feeds retro)

#219 transition table — independent

Critical path: #210 → #211 → #212 (ships standalone value: real dependency scheduling). Everything else compounds on top.