@smartmemory/compose 0.2.51 → 0.2.53-beta

package/server/feature-scan.js

@@ -15,9 +15,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { parse as parseYaml } from 'yaml';
 import { getTargetRoot, resolveProjectPath } from './project-root.js';
 import { relForDisplay } from '../lib/project-paths.js';
 import { assertValidLinkShape } from '../lib/feature-write-guard.js';
+import { depsToEdges } from '../lib/roadmap-graph/model.js';
 
 // ---------------------------------------------------------------------------
 // Metadata extraction
@@ -162,6 +164,9 @@ export function scanFeatures(featuresDir) {
       predecessors: [],
       successors: [],
       group: null,  // explicit group from feature.json overrides derivation
+      priority: null, // track/priority from design.md frontmatter (COMP-ROADMAP-GRAPH-2)
+      deps: null,   // { depends_on?, blocks?, concurrent_with? } from deps.yaml
+      hasFeatureJson: false, // feature.json present = a managed feature (canon)
     };
 
     // Read feature.json if present — supplies optional explicit `group`,
@@ -169,13 +174,48 @@ export function scanFeatures(featuresDir) {
     try {
       const specPath = path.join(featureDir, 'feature.json');
       if (fs.existsSync(specPath)) {
+        feature.hasFeatureJson = true;
         const spec = JSON.parse(fs.readFileSync(specPath, 'utf-8'));
         if (typeof spec.group === 'string' && spec.group.trim()) {
           feature.group = spec.group.trim();
         }
+        // feature.json is canon for status. Set it first (highest precedence) so
+        // the design.md prose loop below cannot override it — the vision store
+        // is a managed projection of feature.json, not a thing that drifts from
+        // it (COMP-ROADMAP-GRAPH-2: kills the feature.json/cockpit status de-sync).
+        if (typeof spec.status === 'string' && spec.status.trim()) {
+          feature.status = normalizeStatus(spec.status);
+        }
       }
     } catch { /* ignore malformed feature.json */ }
 
+    // COMP-ROADMAP-GRAPH-2 (S3): absorb the static collector's edge + track
+    // metadata so a seeded store renders the same canonical graph.
+    // deps.yaml -> typed dependency edges.
+    try {
+      const depsPath = path.join(featureDir, 'deps.yaml');
+      if (fs.existsSync(depsPath)) {
+        const deps = parseYaml(fs.readFileSync(depsPath, 'utf-8')) || {};
+        if (deps && typeof deps === 'object' && !Array.isArray(deps)) feature.deps = deps;
+      }
+    } catch { /* unparseable deps.yaml — skip edges for this feature */ }
+
+    // design.md YAML frontmatter `track`/`priority` (collect.js precedence:
+    // frontmatter track > feature.json group). Rare, but kept faithful.
+    try {
+      const designPath = path.join(featureDir, 'design.md');
+      if (fs.existsSync(designPath)) {
+        const m = fs.readFileSync(designPath, 'utf-8').match(/^---\n([\s\S]*?)\n---/);
+        if (m) {
+          const fm = parseYaml(m[1]) || {};
+          if (fm && typeof fm === 'object' && !Array.isArray(fm)) {
+            if (typeof fm.track === 'string' && fm.track.trim()) feature.group = fm.track.trim();
+            if (typeof fm.priority === 'string' && fm.priority.trim()) feature.priority = fm.priority.trim();
+          }
+        }
+      }
+    } catch { /* invalid frontmatter — ignore */ }
+
     // List artifacts
     try {
       feature.artifacts = fs.readdirSync(featureDir)
@@ -420,179 +460,6 @@ export function writeFeatureGroupToDisk(item, newGroup, featuresDir) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Roadmap graph import
-// ---------------------------------------------------------------------------
-
-/**
- * Parse a roadmap-graph.html file (Cytoscape-based dependency graph).
- * Extracts the `nodes` and `edges` JS arrays from the <script> block.
- *
- * @param {string} htmlPath — absolute path to roadmap-graph.html
- * @returns {{ nodes: Array, edges: Array }}
- */
-export function parseRoadmapGraph(htmlPath) {
-  if (!fs.existsSync(htmlPath)) return { nodes: [], edges: [] };
-
-  const raw = fs.readFileSync(htmlPath, 'utf-8');
-
-  // Extract nodes array
-  const nodesMatch = raw.match(/const\s+nodes\s*=\s*\[([\s\S]*?)\];\s*\n/);
-  const edgesMatch = raw.match(/const\s+edges\s*=\s*\[([\s\S]*?)\];\s*\n/);
-
-  let nodes = [];
-  let edges = [];
-
-  if (nodesMatch) {
-    try {
-      // Wrap in array brackets and evaluate as JSON-ish JS
-      // The data uses single quotes and unquoted keys, so we need to eval
-      nodes = Function(`"use strict"; return [${nodesMatch[1]}]`)();
-    } catch (e) {
-      console.error('[feature-scan] Failed to parse roadmap-graph nodes:', e.message);
-    }
-  }
-
-  if (edgesMatch) {
-    try {
-      edges = Function(`"use strict"; return [${edgesMatch[1]}]`)();
-    } catch (e) {
-      console.error('[feature-scan] Failed to parse roadmap-graph edges:', e.message);
-    }
-  }
-
-  return { nodes, edges };
-}
-
-/**
- * Find roadmap-graph.html in common locations within a project.
- */
-function findRoadmapGraph() {
-  const root = getTargetRoot();
-  const candidates = [
-    path.join(root, 'docs', 'roadmap-graph.html'),
-    path.join(root, 'roadmap-graph.html'),
-  ];
-
-  // Search one level of subdirs for docs/roadmap-graph.html
-  try {
-    const entries = fs.readdirSync(root, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
-      candidates.push(path.join(root, entry.name, 'docs', 'roadmap-graph.html'));
-      candidates.push(path.join(root, entry.name, 'roadmap-graph.html'));
-    }
-  } catch { /* skip */ }
-
-  for (const p of candidates) {
-    if (fs.existsSync(p)) return p;
-  }
-  return null;
-}
-
-const GRAPH_STATUS_MAP = {
-  planned: 'planned',
-  parked: 'parked',
-  partial: 'in_progress',
-  open: 'in_progress',
-  complete: 'complete',
-};
-
-const GRAPH_EDGE_MAP = {
-  dep: 'blocks',
-  concurrent: 'supports',
-};
-
-/**
- * Seed vision store from a roadmap-graph.html file.
- * Creates items for nodes and connections for edges.
- */
-export function seedFromRoadmapGraph(store) {
-  const graphPath = findRoadmapGraph();
-  if (!graphPath) return { items: 0, connections: 0 };
-
-  const { nodes, edges } = parseRoadmapGraph(graphPath);
-  if (nodes.length === 0) return { items: 0, connections: 0 };
-
-  console.log(`[vision] Roadmap graph: ${nodes.length} nodes, ${edges.length} edges from ${graphPath}`);
-
-  const seeded = { items: 0, connections: 0 };
-  const idMap = new Map(); // graphNodeId → visionItemId
-
-  // Create/update items from nodes
-  for (const node of nodes) {
-    // Look for existing item by featureCode or title
-    let item = Array.from(store.items.values()).find(
-      i => i.lifecycle?.featureCode === node.id || i.title === node.id
-    );
-
-    const status = GRAPH_STATUS_MAP[node.status] || 'planned';
-    const description = [
-      node.name || '',
-      node.desc || '',
-      node.track ? `Track: ${node.track}` : '',
-      node.priority ? `Priority: ${node.priority}` : '',
-    ].filter(Boolean).join('\n');
-
-    if (!item) {
-      item = store.createItem({
-        type: 'feature',
-        title: node.id,
-        description,
-        status,
-        phase: 'planning',
-        confidence: status === 'complete' ? 3 : node.priority === 'high' ? 1 : 0,
-      });
-      try {
-        store.updateLifecycle(item.id, { featureCode: node.id });
-      } catch { /* skip */ }
-      item = store.items.get(item.id);
-      seeded.items++;
-    } else {
-      // Update description and status if richer
-      const updates = {};
-      if (description.length > (item.description || '').length) {
-        updates.description = description;
-      }
-      if (status !== item.status && status !== 'planned') {
-        updates.status = status;
-      }
-      if (Object.keys(updates).length > 0) {
-        store.updateItem(item.id, updates);
-      }
-    }
-
-    idMap.set(node.id, item.id);
-  }
-
-  // Create connections from edges
-  for (const edge of edges) {
-    const fromId = idMap.get(edge.source);
-    const toId = idMap.get(edge.target);
-    if (!fromId || !toId) continue;
-
-    const type = GRAPH_EDGE_MAP[edge.type] || 'informs';
-
-    // Check existing
-    const exists = Array.from(store.connections.values()).some(
-      c => (c.fromId === fromId && c.toId === toId) ||
-           (c.fromId === toId && c.toId === fromId)
-    );
-    if (exists) continue;
-
-    try {
-      store.createConnection({ fromId, toId, type });
-      seeded.connections++;
-    } catch { /* skip */ }
-  }
-
-  if (seeded.items || seeded.connections) {
-    console.log(`[vision] Roadmap graph: ${seeded.items} items, ${seeded.connections} connections seeded`);
-  }
-  return seeded;
-}
-
 // ---------------------------------------------------------------------------
 // Seed
 // ---------------------------------------------------------------------------
@@ -631,6 +498,7 @@ export function seedFeatures(features, store) {
         confidence: feature.confidence,
         files: feature.artifacts.map(a => artifactPath(feature, a)),
         ...(feature.group ? { group: feature.group } : {}),
+        ...(feature.priority ? { priority: feature.priority } : {}),
       });
       try {
         store.updateLifecycle(featureItem.id, { featureCode: feature.name, currentPhase: 'explore_design' });
@@ -656,6 +524,9 @@ export function seedFeatures(features, store) {
       if (feature.group && feature.group !== featureItem.group) {
         updates.group = feature.group;
       }
+      if (feature.priority && feature.priority !== featureItem.priority) {
+        updates.priority = feature.priority;
+      }
       if (Object.keys(updates).length > 0) {
         store.updateItem(featureItem.id, updates);
         seeded.updated++;
@@ -713,6 +584,49 @@ export function seedFeatures(features, store) {
     }
   }
 
+  // Fourth pass (COMP-ROADMAP-GRAPH-2 S3a): deps.yaml dependency edges as typed
+  // connections — `dep` -> blocks (directed), `concurrent` -> supports. These
+  // structural edges are RECONCILED, not appended: deps.yaml is canon, so a
+  // removed/retargeted dep must drop the stale edge from the live store too
+  // (else the cockpit export drifts from the canonical projection). Endpoints
+  // that resolve to no local item (external/missing) are skipped — buildGraph
+  // would drop their edges anyway.
+  const DEP_EDGE_CONN_TYPE = { dep: 'blocks', concurrent: 'supports' };
+  const STRUCTURAL_TYPES = new Set(['blocks', 'supports']);
+  const managedIds = new Set(featureItemMap.values());
+  const desiredStructural = new Set(); // `${fromId}|${toId}|${type}`
+  for (const feature of features) {
+    if (!feature.deps) continue;
+    for (const edge of depsToEdges(feature.name, feature.deps)) {
+      const fromId = featureItemMap.get(edge.from);
+      const toId = featureItemMap.get(edge.to);
+      const connType = DEP_EDGE_CONN_TYPE[edge.type];
+      if (!fromId || !toId || !connType) continue;
+      desiredStructural.add(`${fromId}|${toId}|${connType}`);
+    }
+  }
+  // Remove stale structural edges between two managed features that deps.yaml no
+  // longer declares (feature relationships are source-managed, not hand-edited).
+  for (const c of Array.from(store.connections.values())) {
+    if (!STRUCTURAL_TYPES.has(c.type)) continue;
+    if (!managedIds.has(c.fromId) || !managedIds.has(c.toId)) continue;
+    if (!desiredStructural.has(`${c.fromId}|${c.toId}|${c.type}`)) {
+      store.deleteConnection(c.id);
+    }
+  }
+  // Add any missing desired structural edges.
+  for (const key of desiredStructural) {
+    const [fromId, toId, connType] = key.split('|');
+    const exists = Array.from(store.connections.values()).some(
+      c => c.fromId === fromId && c.toId === toId && c.type === connType
+    );
+    if (exists) continue;
+    try {
+      store.createConnection({ fromId, toId, type: connType });
+      seeded.connections++;
+    } catch { /* skip invalid */ }
+  }
+
   if (seeded.features || seeded.updated || seeded.connections) {
     console.log(`[vision] Feature scan: ${seeded.features} new, ${seeded.updated} updated, ${seeded.connections} connections`);
   }

package/server/file-watcher.js

@@ -14,6 +14,24 @@ import { resolveDocsPathFromConfig, resolveFeaturesPathFromConfig } from '../lib
 
 const PROJECT_ROOT = getTargetRoot();
 
+/**
+ * fs.watch fileFilter for the pipelines/ watch (COMP-PIPE-EDIT-6): only
+ * *.stratum.yaml files trigger a specChanged. `filename` is what fs.watch hands
+ * us (a name, possibly with a subdir prefix on recursive watches).
+ */
+export function isStratumSpecFile(filename) {
+  return typeof filename === 'string' && filename.endsWith('.stratum.yaml');
+}
+
+/**
+ * Shape of the vision-WS `specChanged` broadcast (COMP-PIPE-EDIT-6). `file` is a
+ * BASENAME (editorSpecFile is a bare filename, so the store compares on basename);
+ * `path` carries the prefixed relative path for diagnostics.
+ */
+export function buildSpecChangedMessage(file, relativePath) {
+  return { type: 'specChanged', file, path: relativePath };
+}
+
 export class FileWatcherServer {
   constructor() {
     this.clients = new Set();
@@ -215,6 +233,21 @@ export class FileWatcherServer {
       }
     });
 
+    // Watch pipelines/ for *.stratum.yaml changes (COMP-PIPE-EDIT-6). A spec the
+    // pipeline editor has open can be edited externally (another writer, the user
+    // editing the file directly). The editor store lives on the VISION WS, not
+    // /ws/files, so emit a DEDICATED `specChanged` message via the onSpecChanged
+    // callback (wired in server/index.js to visionServer.broadcastMessage), NOT a
+    // `fileChanged` on this server's /ws/files. The payload carries `file` as a
+    // BASENAME because editorSpecFile is a bare filename (a prefixed relative path
+    // would never match the store's compare).
+    const pipelinesDir = path.join(PROJECT_ROOT, 'pipelines');
+    watchDir(pipelinesDir, 'pipelines', (relativePath, fullPath) => {
+      if (typeof this.onSpecChanged === 'function') {
+        this.onSpecChanged(buildSpecChangedMessage(path.basename(fullPath), relativePath));
+      }
+    }, isStratumSpecFile);
+
     // Watch .compose/data/ for active-build.json changes
     const self = this;
     const dataDir = path.join(PROJECT_ROOT, '.compose', 'data');

package/server/index.js

@@ -8,7 +8,7 @@ import { FileWatcherServer } from './file-watcher.js';
 import { VisionStore } from './vision-store.js';
 import { VisionServer } from './vision-server.js';
 import { SessionManager } from './session-manager.js';
-import { scanFeatures, seedFeatures, scanSubPackages, seedSubPackages, seedFromRoadmapGraph } from './feature-scan.js';
+import { scanFeatures, seedFeatures, scanSubPackages, seedSubPackages } from './feature-scan.js';
 import { attachGraphExportRoutes } from './graph-export.js';
 import { attachWorkspaceRoutes } from './workspace-routes.js';
 import { attachGraphLayoutRoutes } from './graph-layout-routes.js';
@@ -168,13 +168,12 @@ app.post('/api/project/switch', (req, res) => {
     ensureDataDir();
     // Reload store from new data directory
     visionStore.reloadFrom(result.dataDir);
-    // Re-scan features, sub-packages, and roadmap graph from new project
+    // Re-scan features and sub-packages from new project
     try {
       const features = scanFeatures();
       if (features.length > 0) seedFeatures(features, visionStore);
       const packages = scanSubPackages();
       if (packages.length > 0) seedSubPackages(packages, visionStore);
-      seedFromRoadmapGraph(visionStore);
     } catch (err) {
       console.error('[compose] Feature scan after switch:', err.message);
     }
@@ -201,13 +200,12 @@ const sessionManager = new SessionManager({
 const visionServer = new VisionServer(visionStore, sessionManager, { config: projectConfig });
 visionServer.attach(server, app);
 
-// Seed feature folders, sub-packages, and roadmap graph into vision store on startup
+// Seed feature folders and sub-packages into vision store on startup
 try {
   const features = scanFeatures();
   if (features.length > 0) seedFeatures(features, visionStore);
   const packages = scanSubPackages();
   if (packages.length > 0) seedSubPackages(packages, visionStore);
-  seedFromRoadmapGraph(visionStore);
 } catch (err) {
   console.error('[compose] Feature scan startup error:', err.message);
 }
@@ -231,6 +229,13 @@ fileWatcher.onBuildStateChanged = (state) => {
   }
 };
 
+// Wire pipelines/*.stratum.yaml external changes → broadcast `specChanged` on
+// the VISION WS (COMP-PIPE-EDIT-6 — the channel the pipeline editor store uses,
+// not /ws/files). The message already carries { type:'specChanged', file, path }.
+fileWatcher.onSpecChanged = (message) => {
+  visionServer.broadcastMessage(message);
+};
+
 // ---------------------------------------------------------------------------
 // Static serving + SPA fallback (BOTH modes — additive)
 // Mounted AFTER all API routes so /api/* is never shadowed.

package/server/lifecycle-guard.js

@@ -22,6 +22,14 @@ import {
   guardTransition as _guardTransition,
 } from './stratum-client.js';
 import { setFeatureStatus as _setFeatureStatus } from '../lib/feature-writer.js';
+import {
+  resolveMode,
+  getMode,
+  transitionsOf,
+  completablePhaseOf,
+  terminalOf,
+  edgeEvidenceOf,
+} from '../lib/lifecycle-modes.js';
 
 // ---------------------------------------------------------------------------
 // Canonical phase graph (compose-owned data — single source of truth)
@@ -54,7 +62,10 @@ export const TERMINAL = new Set(['complete', 'killed']);
  * be a superset of every edge vision-routes will legally request, or the guard
  * would reject a transition the app considers valid.
  */
-export function buildPhaseGraph(transitions = BASE_TRANSITIONS) {
+export function buildPhaseGraph(mode = 'build') {
+  const transitions = transitionsOf(mode);
+  const completable = completablePhaseOf(mode);
+  const terminal = new Set(terminalOf(mode));
   const graph = {};
   const nodes = new Set();
   for (const [from, tos] of Object.entries(transitions)) {
@@ -62,18 +73,18 @@ export function buildPhaseGraph(transitions = BASE_TRANSITIONS) {
     nodes.add(from);
     for (const t of tos) nodes.add(t);
   }
-  // ship → complete (the highest-consequence edge; implemented separately in
-  // vision-routes at /lifecycle/complete, so absent from BASE_TRANSITIONS).
-  graph.ship = [...(graph.ship || []), 'complete'];
+  // <completable phase> → complete (the highest-consequence edge; implemented
+  // separately in vision-routes at /lifecycle/complete, so absent from the mode's
+  // forward transitions). For build this is `ship → complete`.
+  graph[completable] = [...(graph[completable] || []), 'complete'];
   // Every non-terminal phase → killed (vision-routes /lifecycle/kill allows
-  // kill from any non-terminal phase, including ship).
+  // kill from any non-terminal phase, including the completable phase).
   for (const s of nodes) {
-    if (TERMINAL.has(s)) continue;
+    if (terminal.has(s)) continue;
     graph[s] = graph[s] || [];
     if (!graph[s].includes('killed')) graph[s].push('killed');
   }
-  graph.complete = [];
-  graph.killed = [];
+  for (const t of terminal) graph[t] = [];
   return graph;
 }
 
@@ -86,17 +97,19 @@ export function buildPhaseGraph(transitions = BASE_TRANSITIONS) {
  *
  * @param {string} featureRelDir e.g. "docs/features/FEAT-1"
  */
-export function edgePredicates(featureRelDir) {
+export function edgePredicates(featureRelDir, mode = 'build') {
   const det = (id, file) => ({
     id,
     type: 'deterministic',
     statement: `server_file_exists('${featureRelDir}/${file}')`,
   });
-  return {
-    'explore_design->blueprint': [det('design_md', 'design.md')],
-    'blueprint->verification': [det('blueprint_md', 'blueprint.md')],
-    'plan->execute': [det('plan_md', 'plan.md')],
-  };
+  const out = {};
+  // edgeEvidence is `{ 'from->to': 'file.md' }` per mode (build's is the legacy
+  // 3 edges verbatim). The predicate id matches the legacy naming: design.md → design_md.
+  for (const [edge, file] of Object.entries(edgeEvidenceOf(mode))) {
+    out[edge] = [det(file.replace(/\.md$/, '_md'), file)];
+  }
+  return out;
 }
 
 /**
@@ -105,9 +118,15 @@ export function edgePredicates(featureRelDir) {
  * `compose:<FC>` would let two compose projects sharing a feature code collide on
  * one ledger/current-state. The project-path hash prevents that.
  */
-export function resourceId(featureCode, workspaceRoot) {
+export function resourceId(featureCode, workspaceRoot, mode = 'build') {
   const hash = createHash('sha256').update(path.resolve(workspaceRoot)).digest('hex').slice(0, 12);
-  return `compose:${hash}:${featureCode}`;
+  const m = resolveMode(mode);
+  // build keeps the LEGACY id (no mode segment) so in-flight build guards are
+  // never orphaned; non-build modes get a namespaced id so two modes on one
+  // feature can't collide on a single guard ledger/current-state.
+  return m === 'build'
+    ? `compose:${hash}:${featureCode}`
+    : `compose:${hash}:${m}:${featureCode}`;
 }
 
 // ---------------------------------------------------------------------------
@@ -224,8 +243,21 @@ export function _testOnly_resetGuardCache() { _registered.clear(); }
  * which is pinned to getTargetRoot() and would drift for a non-current project
  * root). The relative dir is baked into the immutable guard registration, so it
  * must reflect the tree the routes actually serve.
+ *
+ * COMP-ROADMAP-PLAN S7: mode-aware, mirroring `resolveItemDir` (build.js:670-674).
+ * The mode's `artifactRoot` is a token: `'features'` resolves the (override-aware)
+ * config-backed `paths.features` dir — build stays byte-identical; any other token
+ * (`docs/bugs`, `docs/plans`) is a literal repo-relative root used as `<root>/<code>`.
+ * Without this, plan/bug evidence would be looked up under `docs/features` and the
+ * guard would block `advance` (C11).
  */
-function _featureRelDir(featureCode, workspaceRoot) {
+function _featureRelDir(featureCode, workspaceRoot, mode = 'build') {
+  const artifactRoot = getMode(mode).runner.artifactRoot;
+  if (artifactRoot !== 'features') {
+    // Literal repo-relative root (docs/bugs, docs/plans) — no config override.
+    return `${artifactRoot}/${featureCode}`;
+  }
+  // Build: keep the config-backed paths.features resolution.
   let featuresRel = 'docs/features';
   try {
     const cfg = JSON.parse(readFileSync(path.join(workspaceRoot, '.compose', 'compose.json'), 'utf-8'));
@@ -234,6 +266,11 @@ function _featureRelDir(featureCode, workspaceRoot) {
   return `${featuresRel}/${featureCode}`;
 }
 
+/** Test-only seam for the mode-aware feature-dir resolver. */
+export function _testOnly_featureRelDir(featureCode, workspaceRoot, mode = 'build') {
+  return _featureRelDir(featureCode, workspaceRoot, mode);
+}
+
 /**
  * The configured evidence-bound-completion test command (array form, e.g.
  * ["npm","test"]) from `<workspaceRoot>/.compose/compose.json` `guard.testCommand`,
@@ -259,18 +296,18 @@ export function guardTestCommand(workspaceRoot) {
  *
  * @returns the register result, or {error} on guard failure.
  */
-export async function ensureGuard(featureCode, currentPhase, workspaceRoot) {
-  const rid = resourceId(featureCode, workspaceRoot);
+export async function ensureGuard(featureCode, currentPhase, workspaceRoot, mode = 'build') {
+  const rid = resourceId(featureCode, workspaceRoot, mode);
   if (_registered.has(rid)) return { guard_id: rid, status: 'cached' };
 
   let res;
   try {
     res = await _client.register({
       resourceId: rid,
-      graph: buildPhaseGraph(),
-      edgePredicates: edgePredicates(_featureRelDir(featureCode, workspaceRoot)),
+      graph: buildPhaseGraph(mode),
+      edgePredicates: edgePredicates(_featureRelDir(featureCode, workspaceRoot, mode), mode),
       initial: currentPhase,
-      terminal: ['complete', 'killed'],
+      terminal: terminalOf(mode),
       stakes: {},
       workspaceRoot,
     });
@@ -293,13 +330,13 @@ export async function ensureGuard(featureCode, currentPhase, workspaceRoot) {
  * @returns {Promise<{applied:boolean, refused?:boolean, verdict?:object,
  *   ledgerRef?:string, currentState?:string, error?:object}>}
  */
-export async function guardedTransition({ featureCode, from, to, workspaceRoot, commitSha, resolvedBy = 'agent' }) {
-  const reg = await ensureGuard(featureCode, from, workspaceRoot);
+export async function guardedTransition({ featureCode, from, to, workspaceRoot, commitSha, resolvedBy = 'agent', mode = 'build' }) {
+  const reg = await ensureGuard(featureCode, from, workspaceRoot, mode);
   if (reg && (reg.error || reg.status === 'error')) {
     return { applied: false, error: reg.error || reg };
   }
 
-  const rid = resourceId(featureCode, workspaceRoot);
+  const rid = resourceId(featureCode, workspaceRoot, mode);
   const artifacts = commitSha ? { commit_sha: commitSha } : {};
   // No idempotency_key: a refuse→fix→retry is a NEW logical attempt that must
   // re-evaluate evidence, but it carries an identical (from,to,artifacts)