@smartmemory/compose 0.2.39-beta → 0.2.41-beta

package/bin/compose.js

@@ -329,14 +329,16 @@ async function runDoctor(flags = []) {
 // compose init — project-local setup
 // ---------------------------------------------------------------------------
 
-async function runInit(flags) {
+async function runInit(flags, cwdOverride) {
   const noStratum = flags.includes('--no-stratum')
   const noLifecycle = flags.includes('--no-lifecycle')
   // init creates the workspace — never go through resolveCwdWithWorkspace (which
   // requires one to exist). Strip --workspace if present to avoid leaving it in
   // the shared args array for downstream subcommands.
   getWorkspaceFlag(args)
-  const cwd = process.cwd()
+  // cwdOverride lets callers (e.g. runUpdate) target the resolved workspace root
+  // instead of process.cwd(), which differs when run from a subdirectory.
+  const cwd = cwdOverride || process.cwd()
 
   // 1. Create .compose/ directory
   const composeDir = join(cwd, '.compose')
@@ -373,8 +375,10 @@ async function runInit(flags) {
   // 4. Write .compose/compose.json (merge with existing if present)
   const configPath = join(composeDir, 'compose.json')
   let existing = {}
+  let existingConfigCorrupt = false
   if (existsSync(configPath)) {
-    try { existing = JSON.parse(readFileSync(configPath, 'utf-8')) } catch {}
+    try { existing = JSON.parse(readFileSync(configPath, 'utf-8')) }
+    catch { existingConfigCorrupt = true }
   }
 
   const agentsConfig = {}
@@ -388,6 +392,10 @@ async function runInit(flags) {
   }
 
   const config = {
+    // Preserve unknown top-level keys (tracker, roadmap, stateVersion, …) — the
+    // explicit keys below override the merged sub-objects. Without this spread,
+    // init/upgrade silently drops e.g. `roadmap.narrative` and `tracker` config.
+    ...existing,
     version: 2,
     capabilities: {
       ...(existing.capabilities || {}),
@@ -418,6 +426,23 @@ async function runInit(flags) {
   // 5. Create .compose/data/
   mkdirSync(join(composeDir, 'data'), { recursive: true })
 
+  // 5a. Run pending feature.json state migrations (COMP-MIGRATE-ON-UPGRADE).
+  // Uses init's own resolved cwd; never aborts init on a migration fault. Skip
+  // when the prior compose.json was corrupt — init just normalized it to a
+  // default, so its tracker/paths can't be trusted to scope the migration.
+  if (existingConfigCorrupt) {
+    console.warn('state migration skipped: prior compose.json was unreadable (normalized to default; re-run `compose migrate-state` after verifying config)')
+  } else {
+    try {
+      const { runStateMigrations, summarizeMigrationReport } = await import('../lib/state-migrations.js')
+      const rep = runStateMigrations(cwd, {})
+      const line = summarizeMigrationReport(rep)
+      if (line && !rep.noop) console.log(line)
+    } catch (err) {
+      console.warn(`state migration skipped: ${err.message}`)
+    }
+  }
+
   // 5b. Scaffold docs/context/ with ambient context templates
   const contextDir = join(cwd, config.paths.context)
   mkdirSync(contextDir, { recursive: true })
@@ -669,7 +694,11 @@ async function runUpdate(flags) {
   if (existsSync(join(cwd, '.compose', 'compose.json'))) {
     console.log('')
     console.log(`Refreshing project at ${cwd}...`)
-    await runInit([])
+    // Thread the RESOLVED workspace root into runInit (it otherwise uses
+    // process.cwd(), which differs when upgrading from a subdirectory). This
+    // makes all of init's refresh — including its state-migration step — target
+    // the right workspace (COMP-MIGRATE-ON-UPGRADE finding 6).
+    await runInit([], cwd)
   }
 
   console.log('')
@@ -704,6 +733,25 @@ if (cmd === 'update' || cmd === 'upgrade') {
   process.exit(0)
 }
 
+if (cmd === 'migrate-state') {
+  // COMP-MIGRATE-ON-UPGRADE — run pending feature.json state migrations explicitly.
+  // Distinct from `compose roadmap migrate` (ROADMAP→feature.json backfill).
+  const { root: cwd } = resolveCwdWithWorkspace(args)
+  const dryRun = args.includes('--dry-run')
+  const { runStateMigrations, summarizeMigrationReport } = await import('../lib/state-migrations.js')
+  const rep = runStateMigrations(cwd, { dryRun })
+  if (rep.skipped) {
+    console.log(`migrate-state: skipped (${rep.skipped})`)
+    process.exit(0)
+  }
+  console.log(summarizeMigrationReport(rep))
+  for (const m of rep.perMigration) {
+    if (m.touched.length) console.log(`  [${m.id}] v${m.version}: ${m.touched.join(', ')}`)
+  }
+  for (const e of rep.parseErrors) console.error(`  unparseable: ${e.path} — ${e.message}`)
+  process.exit(0)
+}
+
 if (cmd === 'install') {
   // Backwards-compat: run both init + setup
   await runInit(args)

package/lib/get-roadmap.js

@@ -0,0 +1,140 @@
+/**
+ * get-roadmap.js — COMP-MCP-ROADMAP-READ.
+ *
+ * Read-only roadmap reader for the compose MCP `get_roadmap` tool. Renders the
+ * roadmap from canon (feature.json) WITHOUT writing any file, parses rows via the
+ * shared parseRoadmap, and reports a staleness flag vs the on-disk ROADMAP.md.
+ *
+ * Invariants:
+ *   - Never mutates the filesystem (no writeRoadmap / renderRoadmap).
+ *   - Narrative-owned workspaces read ROADMAP.md verbatim (no console.warn path),
+ *     and are never reported stale (the file IS the canon).
+ *   - Row parsing reuses parseRoadmap — no second hand-rolled regex.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { generateRoadmap } from './roadmap-gen.js';
+import { isNarrativeOwned } from './roadmap-config.js';
+import { parseRoadmap, parseStatusToken } from './roadmap-parser.js';
+
+// Whole `**Last updated:** <date>` line — date-only and per-day, so it is
+// stripped (not literal-matched) before drift comparison.
+const LAST_UPDATED_RE = /^\*\*Last updated:\*\*.*$/m;
+
+const ACTIVE_STATUSES = new Set(['IN_PROGRESS', 'PARTIAL']);
+
+// Normalized status token -> summary bucket.
+const BUCKET = {
+  COMPLETE: 'complete',
+  IN_PROGRESS: 'active',
+  PARTIAL: 'active',
+  PLANNED: 'planned',
+  BLOCKED: 'blocked',
+  PARKED: 'parked',
+  SUPERSEDED: 'superseded',
+};
+
+function emptySummary() {
+  return { complete: 0, active: 0, planned: 0, blocked: 0, parked: 0, superseded: 0 };
+}
+
+function stripVolatile(text) {
+  return text.replace(LAST_UPDATED_RE, '').trimEnd();
+}
+
+/**
+ * @param {string} root - Project root.
+ * @param {object} [opts]
+ * @param {string} [opts.status] - Comma-list status filter applied to active/blocked + rows.
+ * @param {string} [opts.phase] - Exact phaseId filter applied to active/blocked + rows.
+ * @param {'summary'|'markdown'} [opts.format='summary'] - Omit or include raw markdown.
+ * @param {boolean} [opts.check_drift=true] - Compare render vs on-disk ROADMAP.md.
+ * @param {number} [opts.limit=50] - Cap on the general `rows` list (emitted only when
+ *   a status/phase filter or an explicit limit is supplied — keeps the default call token-safe).
+ */
+export function getRoadmap(root, opts = {}) {
+  const { status, phase, format = 'summary', check_drift = true, limit } = opts ?? {};
+
+  const roadmapPath = join(root, 'ROADMAP.md');
+  const onDisk = existsSync(roadmapPath) ? readFileSync(roadmapPath, 'utf-8') : '';
+
+  // Branch on narrative ownership ourselves: read the file directly for narrative
+  // workspaces (avoids generateRoadmap's console.warn and is a true no-op read).
+  const narrative = isNarrativeOwned(root);
+  const markdown = narrative ? onDisk : generateRoadmap(root, {});
+  const source = narrative ? 'narrative' : 'rendered';
+
+  const rows = parseRoadmap(markdown);
+
+  // Summary counts over ALL rows (anonymous included).
+  const summary = emptySummary();
+  for (const r of rows) {
+    const bucket = BUCKET[parseStatusToken(r.status)];
+    if (bucket) summary[bucket]++;
+  }
+
+  // active/blocked lists exclude anonymous rows. parseRoadmap rewrites
+  // codeless rows to `_anon_${position}` (roadmap-parser.js), so filter on that
+  // prefix — not the raw '—' glyph, which never reaches us.
+  const named = rows.filter((r) => r.code && !r.code.startsWith('_anon_'));
+
+  const matchFilter = (r) => {
+    if (status) {
+      const wanted = status.split(',').map((s) => s.trim().toUpperCase());
+      if (!wanted.includes(parseStatusToken(r.status))) return false;
+    }
+    if (phase && r.phaseId !== phase) return false;
+    return true;
+  };
+  const pick = (r) => ({
+    code: r.code,
+    description: r.description,
+    status: parseStatusToken(r.status),
+    phaseId: r.phaseId,
+  });
+
+  const active = named
+    .filter((r) => ACTIVE_STATUSES.has(parseStatusToken(r.status)))
+    .filter(matchFilter)
+    .map(pick);
+  const blocked = named
+    .filter((r) => parseStatusToken(r.status) === 'BLOCKED')
+    .filter(matchFilter)
+    .map(pick);
+
+  const out = { source, path: roadmapPath, summary, active, blocked };
+
+  // General filtered rows list — emitted only when the caller signals intent via a
+  // status/phase filter or an explicit limit. This is what lets `/roadmap next` read
+  // the PLANNED list structured instead of re-parsing the markdown. The no-arg summary
+  // call stays token-safe (no rows key). Anonymous rows are excluded, same as the lists.
+  const wantsRows = status != null || phase != null || limit != null;
+  if (wantsRows) {
+    // Resolve the row cap with predictable semantics for malformed input: a finite
+    // number is floored and clamped to >= 0 (so limit:-1 → 0 rows, limit:1.5 → 1),
+    // never silently widened. Anything non-finite (no limit, just a status/phase
+    // filter) falls back to the default 50.
+    const cap = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 50;
+    const matched = named.filter(matchFilter).map(pick);
+    out.rowsTotal = matched.length;
+    out.rows = matched.slice(0, cap);
+    out.rowsTruncated = matched.length > cap;
+  }
+
+  if (check_drift) {
+    if (narrative) {
+      out.stale = false; // the content IS the file
+    } else {
+      const drifted = stripVolatile(markdown) !== stripVolatile(onDisk);
+      out.stale = drifted;
+      if (drifted) {
+        out.drift = 'ROADMAP.md differs from the feature.json render (run validate_project --fix to reconcile)';
+      }
+    }
+  }
+
+  if (format === 'markdown') out.markdown = markdown;
+
+  return out;
+}

package/lib/state-migrations.js

@@ -0,0 +1,217 @@
+/**
+ * COMP-MIGRATE-ON-UPGRADE — versioned, eager feature.json state migration.
+ *
+ * `compose upgrade` refreshes code but historically ran no state migration:
+ * vision-state is migrated lazily on every load, but feature.json cold data
+ * (e.g. legacy `complexity: null` that fails the schema oneOf) is never touched
+ * unless the file happens to be rewritten. This runner walks every feature.json
+ * eagerly, applies an ordered registry of pure transforms, and records progress
+ * in a durable, dedicated state file.
+ *
+ * Design: docs/features/COMP-MIGRATE-ON-UPGRADE/design.md (rev 2).
+ *
+ * Invariants:
+ *   - migrateFeature transforms are PURE and TOTAL: no I/O, never throw on
+ *     valid-JSON input. (A throw means a migration-code bug → fail-fast.)
+ *   - The runner owns all I/O, atomicity (temp+rename), and reporting.
+ *   - The stamp lives in .compose/data/migration-state.json — NOT compose.json
+ *     (runInit rewrites compose.json from a fixed shape and would drop it; and a
+ *     torn write to tracker config would break workspace resolution).
+ *   - Convergent: corrupt/unparseable feature.json is REPORTED, not a permanent
+ *     block — the stamp still advances, so one bad file can't re-run the whole
+ *     stack forever.
+ *   - local-provider only; narrative-safe (never regenerates ROADMAP.md).
+ */
+import {
+  readFileSync, writeFileSync, existsSync, mkdirSync,
+  renameSync, unlinkSync, readdirSync,
+} from 'fs';
+import { join } from 'path';
+import { loadFeaturesDir } from './project-paths.js';
+import { writeFeature } from './feature-json.js';
+
+/**
+ * Ordered, append-only migration registry. Each `migrateFeature` is pure/total.
+ * @type {{version:number, id:string, describe:string,
+ *         migrateFeature:(f:object)=>{changed:boolean, feature:object}}[]}
+ */
+// Legacy free-text complexity → schema enum (S/M/L/XL), preserving ordinal intent.
+const COMPLEXITY_SYNONYMS = {
+  xs: 'S', s: 'S', small: 'S', low: 'S', trivial: 'S',
+  m: 'M', medium: 'M', med: 'M', moderate: 'M',
+  l: 'L', large: 'L', high: 'L',
+  xl: 'XL', 'extra-large': 'XL', 'extra large': 'XL', 'very-high': 'XL', 'very high': 'XL',
+};
+const VALID_COMPLEXITY = new Set(['S', 'M', 'L', 'XL']);
+
+export const MIGRATIONS = [
+  {
+    version: 1,
+    id: 'normalize-complexity',
+    describe: 'Normalize legacy free-text complexity to the S/M/L/XL enum; drop null/unmappable (fails the string|number oneOf)',
+    migrateFeature(f) {
+      // Total on any parseable JSON value: a non-object (scalar/array/null)
+      // feature.json is malformed data, not a migration target — never throw.
+      if (!f || typeof f !== 'object' || Array.isArray(f)) return { changed: false, feature: f };
+      if (!('complexity' in f)) return { changed: false, feature: f };
+      const c = f.complexity;
+      // Already schema-valid: a number or an enum member — leave untouched.
+      if (typeof c === 'number') return { changed: false, feature: f };
+      if (typeof c === 'string' && VALID_COMPLEXITY.has(c)) return { changed: false, feature: f };
+      // Mappable legacy free-text → enum.
+      if (typeof c === 'string') {
+        const mapped = COMPLEXITY_SYNONYMS[c.trim().toLowerCase()];
+        if (mapped) return { changed: true, feature: { ...f, complexity: mapped } };
+      }
+      // null or unmappable (object/garbage string) → drop the optional key.
+      const { complexity, ...rest } = f;
+      return { changed: true, feature: rest };
+    },
+  },
+];
+
+function stateFilePath(cwd) {
+  return join(cwd, '.compose', 'data', 'migration-state.json');
+}
+
+/** Read the durable stamp. Absent or corrupt ⇒ {stateVersion:0, applied:[]}. */
+export function readMigrationState(cwd) {
+  const p = stateFilePath(cwd);
+  if (!existsSync(p)) return { stateVersion: 0, applied: [] };
+  try {
+    const parsed = JSON.parse(readFileSync(p, 'utf-8'));
+    return {
+      stateVersion: Number.isInteger(parsed?.stateVersion) ? parsed.stateVersion : 0,
+      applied: Array.isArray(parsed?.applied) ? parsed.applied : [],
+    };
+  } catch {
+    // A corrupt state file is treated as version 0; re-running is idempotent.
+    return { stateVersion: 0, applied: [] };
+  }
+}
+
+function writeMigrationStateAtomic(cwd, state) {
+  const dir = join(cwd, '.compose', 'data');
+  mkdirSync(dir, { recursive: true });
+  const p = join(dir, 'migration-state.json');
+  const tmp = `${p}.tmp.${process.pid}`;
+  try {
+    writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n');
+    renameSync(tmp, p);
+  } catch (err) {
+    try { unlinkSync(tmp); } catch { /* tmp may not exist */ }
+    throw err;
+  }
+}
+
+/**
+ * Tracker classification from `.compose/compose.json`:
+ *   'local'      — tracker absent/null or provider==='local'
+ *   'non-local'  — an explicit non-local provider (e.g. github)
+ *   'unreadable' — config present but not parseable (mirrors factory.js failing
+ *                  fast rather than silently assuming local)
+ */
+function trackerKind(cwd) {
+  let cfg;
+  try {
+    cfg = JSON.parse(readFileSync(join(cwd, '.compose', 'compose.json'), 'utf-8'));
+  } catch {
+    return 'unreadable';
+  }
+  const t = cfg.tracker;
+  if (t === undefined || t === null || !t.provider || t.provider === 'local') return 'local';
+  return 'non-local';
+}
+
+/**
+ * Run pending feature.json state migrations for the workspace at `cwd`.
+ *
+ * @param {string} cwd - workspace root
+ * @param {{dryRun?: boolean}} [opts]
+ * @returns {object} report — one of:
+ *   {skipped:'no-workspace'|'non-local-tracker'}
+ *   {from, to, dryRun, noop:true, perMigration:[], parseErrors:[]}
+ *   {from, to, dryRun, perMigration:[{id,version,touched:[]}], parseErrors:[{path,message}]}
+ * @throws if a migrateFeature transform throws (migration-code bug) — aborts
+ *         WITHOUT advancing the stamp.
+ */
+export function runStateMigrations(cwd, opts = {}) {
+  const dryRun = !!opts.dryRun;
+
+  // Guard: never write stray state into a non-workspace cwd (e.g. when runUpdate
+  // → runInit lands on a process.cwd() that isn't the resolved workspace root).
+  if (!existsSync(join(cwd, '.compose', 'compose.json'))) {
+    return { skipped: 'no-workspace' };
+  }
+  const kind = trackerKind(cwd);
+  if (kind === 'non-local') return { skipped: 'non-local-tracker' };
+  if (kind === 'unreadable') return { skipped: 'unreadable-config' };
+
+  const { stateVersion: from, applied } = readMigrationState(cwd);
+  const pending = MIGRATIONS
+    .filter((m) => m.version > from)
+    .sort((a, b) => a.version - b.version);
+  if (pending.length === 0) {
+    return { from, to: from, dryRun, noop: true, perMigration: [], parseErrors: [] };
+  }
+
+  const featuresDir = loadFeaturesDir(cwd); // honors paths.features override
+  const featuresRoot = join(cwd, featuresDir);
+  const perMigration = pending.map((m) => ({ id: m.id, version: m.version, touched: [] }));
+  const parseErrors = [];
+
+  // Own directory walk — do NOT use listFeatures(): it silently skips unreadable
+  // files, which would hide exactly the cold-data corruption we must surface.
+  let dirs = [];
+  try {
+    dirs = readdirSync(featuresRoot, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name);
+  } catch {
+    dirs = []; // features dir may not exist yet
+  }
+
+  for (const code of dirs) {
+    const fpath = join(featuresRoot, code, 'feature.json');
+    if (!existsSync(fpath)) continue;
+    let feature;
+    try {
+      feature = JSON.parse(readFileSync(fpath, 'utf-8'));
+    } catch (err) {
+      parseErrors.push({ path: fpath, message: err.message });
+      continue;
+    }
+    let changedAny = false;
+    pending.forEach((m, i) => {
+      const res = m.migrateFeature(feature); // pure/total; a throw = migration-code bug → fail-fast
+      if (res.changed) {
+        feature = res.feature;
+        changedAny = true;
+        perMigration[i].touched.push(feature.code || code);
+      }
+    });
+    if (changedAny && !dryRun) {
+      writeFeature(cwd, feature, featuresDir, { validate: false });
+    }
+  }
+
+  const to = pending[pending.length - 1].version;
+  if (!dryRun) {
+    writeMigrationStateAtomic(cwd, {
+      stateVersion: to,
+      applied: applied.concat(pending.map((m) => ({ version: m.version, id: m.id }))),
+    });
+  }
+  return { from, to, dryRun, perMigration, parseErrors };
+}
+
+/** One-line human summary for the upgrade/init narration. */
+export function summarizeMigrationReport(report) {
+  if (!report || report.skipped) return null;
+  if (report.noop) return `state up to date (v${report.to})`;
+  const touched = report.perMigration.reduce((n, m) => n + m.touched.length, 0);
+  const errs = report.parseErrors.length;
+  const dry = report.dryRun ? ' (dry-run)' : '';
+  return `migrated ${touched} feature.json across ${report.perMigration.length} migration(s) `
+    + `→ stateVersion ${report.to}${errs ? `, ${errs} unparseable (reported)` : ''}${dry}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartmemory/compose",
-  "version": "0.2.39-beta",
+  "version": "0.2.41-beta",
   "description": "Structured AI dev pipeline — goal-to-product orchestration with gates, iteration loops, and feature lifecycle management.",
   "author": "SmartMemory",
   "license": "MIT",

package/server/compose-mcp-tools.js

@@ -11,6 +11,7 @@ import path from 'node:path';
 import { ArtifactManager, ARTIFACT_SCHEMAS } from './artifact-manager.js';
 import { getTargetRoot, getDataDir, resolveProjectPath, switchProject, setCurrentWorkspaceId, loadProjectConfig } from './project-root.js';
 import { resolveProfile, isToolAllowed } from './mcp-tool-policy.js';
+import { getRoadmap } from '../lib/get-roadmap.js';
 
 /**
  * COMP-MCP-ENFORCE Slice 3 — kill the `force` escape hatch at the MCP tool
@@ -152,6 +153,12 @@ export function loadSessions() {
 // Tool implementations
 // ---------------------------------------------------------------------------
 
+// COMP-MCP-ROADMAP-READ — read-only roadmap reader. Thin wrapper over
+// lib/get-roadmap.js; never mutates the filesystem.
+export function toolGetRoadmap(args = {}) {
+  return getRoadmap(getTargetRoot(), args ?? {});
+}
+
 export function toolGetVisionItems({ phase, status, type, keyword, limit = 30 }) {
   const { items } = loadVisionState();
 

package/server/compose-mcp.js

@@ -28,6 +28,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import {
   toolGetVisionItems,
+  toolGetRoadmap,
   toolGetItemDetail,
   toolGetPhasesSummary,
   toolGetBlockedItems,
@@ -358,6 +359,20 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'get_roadmap',
+    description: 'Read the current roadmap rendered from canon (feature.json) WITHOUT writing. Returns a status summary, the active/blocked convenience lists, and a staleness flag vs on-disk ROADMAP.md. Pass a status/phase filter or a limit to also get a general `rows` list (e.g. {status:"PLANNED", limit:10} for "what to work on next") — structured rows so callers never re-parse the markdown. Narrative-owned workspaces return the hand-authored file verbatim. Read-only — prefer this over reading ROADMAP.md directly.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', description: 'Filter active/blocked + rows by status (comma-separated): PLANNED, IN_PROGRESS, PARTIAL, BLOCKED, COMPLETE, …' },
+        phase: { type: 'string', description: 'Filter active/blocked + rows to a single phase (matched against phaseId)' },
+        format: { type: 'string', description: '"summary" (default — counts + lists, token-safe) or "markdown" (full rendered text)' },
+        check_drift: { type: 'boolean', description: 'Compare the render against on-disk ROADMAP.md and set stale/drift (default true)' },
+        limit: { type: 'integer', minimum: 0, description: 'Cap on the general `rows` list (default 50). Supplying status/phase/limit emits rows[]/rowsTotal/rowsTruncated; without any of them rows is omitted (token-safe summary). A finite value is floored and clamped to ≥ 0.' },
+      },
+    },
+  },
   {
     name: 'validate_feature',
     description: 'Cross-check a single feature against ROADMAP, vision-state, feature.json, folder contents, linked artifacts, and cross-references. Returns structured findings with severity (error/warning/info). FEATURE_NOT_FOUND emitted as a finding (not thrown) when the code matches strict regex but exists in no source.',
@@ -733,6 +748,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'add_roadmap_entry':        result = await toolAddRoadmapEntry(args); break;
       case 'set_feature_status':       result = await toolSetFeatureStatus(args); break;
       case 'roadmap_diff':             result = await toolRoadmapDiff(args); break;
+      case 'get_roadmap':              result = toolGetRoadmap(args); break;
       case 'link_artifact':            result = await toolLinkArtifact(args); break;
       case 'link_features':            result = await toolLinkFeatures(args); break;
       case 'get_feature_artifacts':    result = await toolGetFeatureArtifacts(args); break;

package/server/mcp-tool-policy.js

@@ -34,7 +34,7 @@ const REVIEWER_ALLOW = [
   'get_vision_items', 'get_item_detail', 'get_phase_summary', 'get_blocked_items',
   'get_current_session', 'get_feature_lifecycle', 'get_feature_artifacts', 'get_feature_links',
   'get_pending_gates', 'get_changelog_entries', 'get_journal_entries', 'get_completions',
-  'validate_feature', 'validate_project', 'roadmap_diff', 'roadmap_graph_check', 'assess_feature_artifacts',
+  'validate_feature', 'validate_project', 'roadmap_diff', 'get_roadmap', 'roadmap_graph_check', 'assess_feature_artifacts',
   'set_workspace', 'get_workspace', 'bind_session',
 ];