@smartmemory/compose 0.2.17-beta → 0.2.19-beta

package/lib/feature-write-guard.js

@@ -0,0 +1,201 @@
+/**
+ * feature-write-guard.js — Write-time feature.json validation (COMP-MCP-VALIDATE-1).
+ *
+ * The feature.json schema (contracts/feature-json.schema.json) and the
+ * cross-reference existence rule were historically enforced ONLY on read, by
+ * lib/feature-validator.js. This module enforces the SAME rules at write time so
+ * malformed shape / invalid link kind / dangling to_code is rejected before
+ * commit — closing the source of FEATURE_JSON_SCHEMA_VIOLATION and
+ * DANGLING_LINK_FEATURES_TARGET.
+ *
+ * Layering: imports only the Ajv SchemaValidator (server/) and the feature-code
+ * regex. It does NOT import feature-json.js, feature-validator.js, or
+ * feature-writer.js — those import this module, so this stays a leaf to keep the
+ * graph acyclic.
+ */
+
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { SchemaValidator } from '../server/schema-validator.js';
+import { FEATURE_CODE_RE_STRICT } from './feature-code.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SCHEMA_PATH = resolve(__dirname, '../contracts/feature-json.schema.json');
+
+// Memoize the compiled validator (the schema is static). This is the only thing
+// safe to cache — code-existence sources change at runtime and are read fresh.
+let _validator = null;
+function validator() {
+  if (!_validator) _validator = new SchemaValidator(SCHEMA_PATH);
+  return _validator;
+}
+
+/**
+ * Thrown when a feature.json write would persist invalid data.
+ * `kind` mirrors the read validator's finding kinds so callers can branch.
+ */
+export class FeatureWriteValidationError extends Error {
+  /**
+   * @param {'FEATURE_JSON_SCHEMA_VIOLATION'|'DANGLING_LINK_FEATURES_TARGET'} kind
+   * @param {string[]} violations
+   */
+  constructor(kind, violations) {
+    super(`${kind}: ${violations.join('; ')}`);
+    this.name = 'FeatureWriteValidationError';
+    this.kind = kind;
+    this.violations = violations;
+  }
+}
+
+/**
+ * Validate a feature's `links[]` against the canonical JSON schema. Throws
+ * FeatureWriteValidationError('FEATURE_JSON_SCHEMA_VIOLATION') for any link-shape
+ * violation (bad `kind` enum, missing `to_code` on a non-external link, malformed
+ * external-link provider fields, …).
+ *
+ * SCOPE (COMP-MCP-VALIDATE-1): only `/links/*` violations are enforced at write
+ * time. Whole-object schema tightening — `complexity` enum convergence, the
+ * `artifacts[].type` enum, `additionalProperties` — is **deliberately deferred**
+ * to COMP-MCP-VALIDATE-SCHEMA-TIGHTEN (see contracts/feature-json.schema.json
+ * field comments), and the writers legitimately produce values that pass only
+ * the permissive read schema today. -1 closes the link-kind / link-shape source
+ * named in its charter, nothing wider.
+ *
+ * @param {object} feature
+ */
+export function assertValidLinkShape(feature) {
+  const { valid, errors } = validator().validateRoot(feature);
+  if (valid) return;
+  const linkErrors = (errors || []).filter((e) => (e.instancePath || '').startsWith('/links'));
+  if (linkErrors.length === 0) return;
+  throw new FeatureWriteValidationError(
+    'FEATURE_JSON_SCHEMA_VIOLATION',
+    linkErrors.map((e) => `${e.instancePath}: ${e.message}`),
+  );
+}
+
+function resolvePaths(cwd) {
+  let featuresRel = 'docs/features';
+  try {
+    const cfg = JSON.parse(readFileSync(join(cwd, '.compose', 'compose.json'), 'utf-8'));
+    if (cfg?.paths?.features) featuresRel = cfg.paths.features;
+  } catch { /* no config — use defaults (mirrors resolveProjectPaths) */ }
+  return {
+    features: join(cwd, featuresRel),
+    roadmap: join(cwd, 'ROADMAP.md'),
+    visionState: join(cwd, '.compose', 'data', 'vision-state.json'),
+  };
+}
+
+/**
+ * Strict feature codes present in a ROADMAP.md table. Self-contained, lean
+ * mirror of the validator's column-aware scan (lib/feature-validator.js:144-202)
+ * — NOT extracted from it, because that loop is dual-purpose (it also builds
+ * citationRows for XREF parsing). We need only the code set.
+ *
+ * @param {string} roadmapPath
+ * @returns {string[]}
+ */
+export function scanRoadmapRows(roadmapPath) {
+  const codes = [];
+  let text;
+  try { text = readFileSync(roadmapPath, 'utf8'); } catch { return codes; }
+
+  let codeIdx = -1, statusIdx = -1;
+  let inTable = false, sawSeparator = false;
+  for (const rawLine of text.split('\n')) {
+    if (/^##\s+/.test(rawLine)) { inTable = false; sawSeparator = false; codeIdx = statusIdx = -1; continue; }
+    const rowMatch = rawLine.match(/^\|(.+)\|\s*$/);
+    if (!rowMatch) { inTable = false; sawSeparator = false; continue; }
+    const cols = rowMatch[1].split('|').map((c) => c.trim());
+    const lower = cols.map((c) => c.toLowerCase());
+    const featureColIdx = lower.findIndex((c) => ['feature', 'code', 'item', 'name'].includes(c));
+    const statusColIdx = lower.findIndex((c) => ['status', 'state'].includes(c));
+    if (featureColIdx >= 0 && statusColIdx >= 0) {
+      codeIdx = featureColIdx; statusIdx = statusColIdx; inTable = true; sawSeparator = false; continue;
+    }
+    if (cols.every((c) => /^[-:]+$/.test(c))) { if (inTable) sawSeparator = true; continue; }
+    if (!inTable || !sawSeparator || codeIdx < 0 || codeIdx >= cols.length) continue;
+    const codeRaw = cols[codeIdx].replace(/\*/g, '').replace(/`/g, '').trim();
+    if (FEATURE_CODE_RE_STRICT.test(codeRaw)) codes.push(codeRaw);
+  }
+  return codes;
+}
+
+/**
+ * The set of feature codes that "exist" in any authoritative source — feature
+ * folders, ROADMAP rows, or vision-state items. Mirrors the union the read
+ * validator's dangling-link check consults (foldersByCode ∪ roadmapByCode ∪
+ * visionByCode). Read fresh every call (no memo): ROADMAP and vision-state
+ * change independently of feature writes in long-lived processes.
+ *
+ * @param {string} cwd
+ * @returns {Set<string>}
+ */
+export function knownFeatureCodes(cwd) {
+  const paths = resolvePaths(cwd);
+  const codes = new Set();
+
+  // Feature folders
+  if (existsSync(paths.features)) {
+    for (const dirent of readdirSync(paths.features, { withFileTypes: true })) {
+      if (dirent.isDirectory() && FEATURE_CODE_RE_STRICT.test(dirent.name)) codes.add(dirent.name);
+    }
+  }
+
+  // ROADMAP rows
+  for (const code of scanRoadmapRows(paths.roadmap)) codes.add(code);
+
+  // Vision-state items
+  try {
+    const vs = JSON.parse(readFileSync(paths.visionState, 'utf8'));
+    for (const item of (Array.isArray(vs.items) ? vs.items : [])) {
+      const code = item?.lifecycle?.featureCode || item?.featureCode;
+      if (code && FEATURE_CODE_RE_STRICT.test(code)) codes.add(code);
+    }
+  } catch { /* missing vision-state — folders/roadmap still apply */ }
+
+  return codes;
+}
+
+/**
+ * Assert every same-project link target (non-external to_code) that this write
+ * INTRODUCES exists. No-op (zero I/O) when the feature carries no such links —
+ * the common write.
+ *
+ * Delta-aware: only links not already present in `opts.priorLinks` (the on-disk
+ * version) are checked. This is the correct write-time semantic — reject new
+ * drift, not pre-existing state — and it makes a legitimately forced
+ * forward-reference durable: once persisted, later unrelated writes (status,
+ * completions, build lifecycle) re-run this guard but skip the now-existing
+ * link, so they don't spuriously throw `DANGLING_LINK_FEATURES_TARGET`.
+ *
+ * Throws FeatureWriteValidationError('DANGLING_LINK_FEATURES_TARGET') for any
+ * newly-introduced missing target unless opts.allowForwardRefs is set (the
+ * explicit force path that introduces the forward-reference in the first place).
+ *
+ * @param {string} cwd
+ * @param {object} feature
+ * @param {{allowForwardRefs?: boolean, priorLinks?: Array}} [opts]
+ */
+export function assertLinkTargetsExist(cwd, feature, opts = {}) {
+  if (opts.allowForwardRefs) return;
+  const links = Array.isArray(feature?.links) ? feature.links : [];
+  const prior = Array.isArray(opts.priorLinks) ? opts.priorLinks : [];
+  const isPrior = (l) => prior.some((p) => p.kind === l.kind && p.to_code === l.to_code);
+  const targets = links
+    .filter((l) => l && l.kind !== 'external' && typeof l.to_code === 'string')
+    .filter((l) => !isPrior(l)) // only newly-introduced links
+    .map((l) => l.to_code);
+  if (targets.length === 0) return; // cheap path — no scan
+
+  const known = knownFeatureCodes(cwd);
+  const missing = targets.filter((code) => code !== feature.code && !known.has(code));
+  if (missing.length > 0) {
+    throw new FeatureWriteValidationError(
+      'DANGLING_LINK_FEATURES_TARGET',
+      missing.map((code) => `${code} does not exist in any source`),
+    );
+  }
+}

package/lib/feature-writer.js

@@ -24,6 +24,7 @@ import { checkOrInsert } from './idempotency.js';
 import { loadFeaturesDir } from './project-paths.js';
 import { checkRoundtrip } from './roadmap-roundtrip.js';
 import { isNarrativeOwned, narrativeOwnedMessage } from './roadmap-config.js';
+import { knownFeatureCodes, FeatureWriteValidationError } from './feature-write-guard.js';
 
 // providerFor is imported lazily (inside each function) to break the
 // module-load-time cycle: factory.js → local-provider.js → feature-writer.js.
@@ -360,6 +361,28 @@ export async function setFeatureStatus(cwd, args) {
     if (args.derived && !allowed.includes(to)) event.derived = true;
     await safeAppendEvent(cwd, event);
 
+    // COMP-MCP-VALIDATE-3: project the new status onto vision-state so it stays
+    // in sync with the canonical feature.json instead of drifting as an orphan
+    // surface. Best-effort — vision-state is a downstream mirror, so its
+    // unavailability must never fail the canonical feature.json/ROADMAP write.
+    // Runs only on a real transition (the from===to noop returns above);
+    // pre-existing drift on an unchanged status is the migration's job.
+    // VisionWriter is dual-dispatch (REST when the server is up → the in-memory
+    // store stays the single writer authority; atomic file write when down).
+    try {
+      const { VisionWriter } = await import('./vision-writer.js');
+      const { featureStatusToVisionStatus } = await import('./status-projection.js');
+      const visStatus = featureStatusToVisionStatus(to);
+      if (visStatus) {
+        const writer = new VisionWriter(join(cwd, '.compose', 'data'));
+        const item = await writer.findFeatureItem(args.code);
+        if (item) await writer.updateItemStatus(item.id, visStatus);
+      }
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.warn(`[feature-writer] vision-state projection failed for ${args.code}: ${err.message}`);
+    }
+
     return { code: args.code, from, to, ts: new Date().toISOString(), roundtrip };
   });
 }
@@ -580,17 +603,34 @@ export async function linkFeatures(cwd, args) {
       l => l.kind === args.kind && l.to_code === args.to_code
     );
 
+    // Re-issuing an existing link without force is a no-op — it introduces no
+    // new state, so it short-circuits BEFORE the dangling guard (otherwise an
+    // idempotent retry of a previously-forced forward-ref would wrongly throw).
     if (matchIdx !== -1 && !args.force) {
       return { from_code: args.from_code, to_code: args.to_code, kind: args.kind, noop: true };
     }
 
+    // COMP-MCP-VALIDATE-1: reject a dangling target for genuinely new/updated
+    // links. Checked after the source-existence guard (a missing source is the
+    // more fundamental error). `force` overrides for intentional forward-refs
+    // (link A→B before B is scaffolded).
+    const targetMissing = !knownFeatureCodes(cwd).has(args.to_code);
+    if (targetMissing && !args.force) {
+      throw new FeatureWriteValidationError(
+        'DANGLING_LINK_FEATURES_TARGET',
+        [`${args.to_code} does not exist in any source (pass force to override)`],
+      );
+    }
+
     const entry = { kind: args.kind, to_code: args.to_code };
     if (args.note) entry.note = args.note;
 
     if (matchIdx !== -1) links[matchIdx] = entry;
     else links.push(entry);
 
-    await provider.putFeature(args.from_code, { ...feature, links });
+    // allowForwardRefs only matters when the target is missing (force path);
+    // when it exists the chokepoint existence re-check passes anyway.
+    await provider.putFeature(args.from_code, { ...feature, links }, { allowForwardRefs: targetMissing });
 
     await safeAppendEvent(cwd, {
       tool: 'link_features',
@@ -599,6 +639,7 @@ export async function linkFeatures(cwd, args) {
       kind: args.kind,
       note: args.note,
       forced: matchIdx !== -1 ? true : undefined,
+      forced_dangling: (args.force && targetMissing) ? true : undefined,
       idempotency_key: args.idempotency_key,
     });
 

package/lib/status-projection.js

@@ -0,0 +1,36 @@
+/**
+ * status-projection.js — the single canonical status mapping (COMP-MCP-VALIDATE-3).
+ *
+ * Projects a feature/ROADMAP status (UPPERCASE roadmap vocabulary) onto the
+ * vision-state status (lowercase tracker vocabulary). Used on WRITE (the
+ * `setFeatureStatus` projection and the back-projection migration) AND on READ
+ * (the validator's `*_VS_VISION_STATE` comparison), so a status written by the
+ * projection can never itself trip STATUS_MISMATCH_*_VS_VISION_STATE — one rule
+ * set, enforced on write and read.
+ *
+ * Pure data, no IO.
+ */
+
+// feature/ROADMAP UPPERCASE status -> vision-state lowercase status.
+const FEATURE_TO_VISION = {
+  PLANNED: 'planned',
+  IN_PROGRESS: 'in_progress',
+  PARTIAL: 'in_progress', // vision cannot represent "partially shipped"
+  COMPLETE: 'complete',
+  BLOCKED: 'blocked',
+  PARKED: 'parked',
+  KILLED: 'killed',
+  SUPERSEDED: 'superseded', // D1: vision VALID_STATUSES gains 'superseded'
+};
+
+/**
+ * @param {string|null|undefined} status  A feature/ROADMAP status (any case).
+ * @returns {string|null} The vision-state status, or null for empty/unknown
+ *   input. Vision-native statuses with no feature-vocab key (e.g. ready/review)
+ *   also return null; callers treat null as "no opinion" — the validator falls
+ *   back to identity, the writer skips the projection.
+ */
+export function featureStatusToVisionStatus(status) {
+  if (!status) return null;
+  return FEATURE_TO_VISION[String(status).toUpperCase()] ?? null;
+}

package/lib/tracker/github-provider.js

@@ -5,6 +5,7 @@ import { GitHubApi } from './github-api.js';
 import { OpLog, Cache, ConflictLedger, Reconciler } from './sync-engine.js';
 import { generateRoadmapFromBase } from '../roadmap-gen.js';
 import { spliceChangelog } from '../changelog-writer.js';
+import { assertValidLinkShape } from '../feature-write-guard.js';
 
 const META_RE = /<!--compose-feature\n([\s\S]*?)\n-->/;
 function encodeBody(obj) {
@@ -107,7 +108,8 @@ export class GitHubProvider extends TrackerProvider {
       );
   }
 
-  async createFeature(code, obj) {
+  async createFeature(code, obj, opts = {}) {
+    if (opts.validate !== false) assertValidLinkShape(obj);
     return this._lock(code, async () => {
       // Idempotent: if already in cache, return it.
       const existing = await this.cache.get(code);
@@ -120,7 +122,11 @@ export class GitHubProvider extends TrackerProvider {
     });
   }
 
-  async putFeature(code, obj) {
+  async putFeature(code, obj, opts = {}) {
+    // COMP-MCP-VALIDATE-1: enforce link-shape on the GitHub backend too (same
+    // rule as the local chokepoint). Existence is local-folder semantics and is
+    // not applied here. `validate:false` opts out (migration/fixture planting).
+    if (opts.validate !== false) assertValidLinkShape(obj);
     return this._lock(code, async () => {
       const cur = await this.cache.get(code);
       if (cur && obj.status && obj.status !== cur.status) {
@@ -140,7 +146,8 @@ export class GitHubProvider extends TrackerProvider {
   }
 
   // Raw write that allows status change (used by setStatus / policy layers).
-  async persistFeatureRaw(code, obj) {
+  async persistFeatureRaw(code, obj, opts = {}) {
+    if (opts.validate !== false) assertValidLinkShape(obj);
     return this._lock(code, async () => {
       await this.cache.put(code, obj, { pending: true });
       await this.cache.markPending(code);

package/lib/tracker/local-provider.js

@@ -62,12 +62,12 @@ export class LocalFileProvider extends TrackerProvider {
     return readFeature(this.cwd, code, this.featuresDir);
   }
 
-  async putFeature(code, obj) {
+  async putFeature(code, obj, opts = {}) {
     const cur = readFeature(this.cwd, code, this.featuresDir);
     if (cur && Object.prototype.hasOwnProperty.call(obj, 'status') && obj.status !== cur.status) {
       throw new Error(`putFeature: status delta (${cur.status}->${obj.status}) not allowed; use setStatus`);
     }
-    writeFeature(this.cwd, { ...obj, code }, this.featuresDir);
+    writeFeature(this.cwd, { ...obj, code }, this.featuresDir, opts);
     return readFeature(this.cwd, code, this.featuresDir);
   }
 

package/package.json

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

package/scripts/backproject-vision-status.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * backproject-vision-status.mjs — one-time back-projection of historical
+ * vision-state status drift (COMP-MCP-VALIDATE-3).
+ *
+ * The typed writers now project status onto vision-state on every transition,
+ * but historical vision-state was never reconciled. This script projects the
+ * canonical feature.json status onto each bound vision item, clearing the
+ * pre-existing STATUS_MISMATCH_*_VS_VISION_STATE findings the write-time hook
+ * cannot reach (they predate any new mutation).
+ *
+ * Idempotent: a second run stages zero changes. Dry-run by default; pass
+ * --apply to write. Operates on the project root (default: process.cwd()),
+ * NOT compose's own data/.
+ *
+ *   node scripts/backproject-vision-status.mjs            # dry-run, cwd
+ *   node scripts/backproject-vision-status.mjs --apply    # write
+ *   node scripts/backproject-vision-status.mjs --root /path/to/project --apply
+ */
+
+import { readFileSync, writeFileSync, renameSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import crypto from 'node:crypto';
+import { loadFeaturesDir } from '../lib/project-paths.js';
+import { featureStatusToVisionStatus } from '../lib/status-projection.js';
+
+/**
+ * Compute (and optionally apply) the back-projection for one project root.
+ *
+ * @param {object} opts
+ * @param {string} opts.root   Project root containing .compose/data + features dir.
+ * @param {boolean} [opts.apply=false]  Write the reconciled state when true.
+ * @returns {{changes: Array<{code:string, id:string, from:string|null, to:string}>,
+ *           skipped: number, total: number, applied: boolean}}
+ */
+export function backprojectVisionStatus({ root, apply = false }) {
+  const visionPath = join(root, '.compose', 'data', 'vision-state.json');
+  if (!existsSync(visionPath)) {
+    return { changes: [], skipped: 0, total: 0, applied: false };
+  }
+  const state = JSON.parse(readFileSync(visionPath, 'utf-8'));
+  const items = Array.isArray(state.items) ? state.items : [];
+  const featuresDir = join(root, loadFeaturesDir(root));
+
+  const changes = [];
+  let skipped = 0;
+  for (const item of items) {
+    const code = item.lifecycle?.featureCode || item.featureCode;
+    if (!code) { skipped++; continue; }
+    const fjPath = join(featuresDir, code, 'feature.json');
+    if (!existsSync(fjPath)) { skipped++; continue; } // UI-only / external items
+    let feature;
+    try {
+      feature = JSON.parse(readFileSync(fjPath, 'utf-8'));
+    } catch {
+      skipped++; continue;
+    }
+    const target = featureStatusToVisionStatus(feature.status);
+    if (!target) { skipped++; continue; }
+    if (item.status !== target) {
+      changes.push({ code, id: item.id, from: item.status ?? null, to: target });
+      item.status = target;
+    }
+  }
+
+  if (apply && changes.length > 0) {
+    const tmp = `${visionPath}.tmp.${crypto.randomUUID()}`;
+    writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+    renameSync(tmp, visionPath);
+  }
+
+  return { changes, skipped, total: items.length, applied: apply && changes.length > 0 };
+}
+
+// ── CLI ──────────────────────────────────────────────────────────────────────
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMain) {
+  const argv = process.argv.slice(2);
+  const apply = argv.includes('--apply');
+  const rootIdx = argv.indexOf('--root');
+  const root = rootIdx !== -1 ? argv[rootIdx + 1] : process.cwd();
+
+  const { changes, skipped, total, applied } = backprojectVisionStatus({ root, apply });
+
+  console.log(`Back-projection — ${total} vision items, ${skipped} skipped (no bound feature.json).`);
+  if (changes.length === 0) {
+    console.log('No drift. vision-state already matches canonical feature.json status.');
+  } else {
+    console.log(`${changes.length} item(s) ${applied ? 'reconciled' : 'would change'}:`);
+    for (const c of changes) {
+      console.log(`  ${c.code.padEnd(28)} ${String(c.from).padEnd(12)} → ${c.to}`);
+    }
+    if (!applied) console.log('\nDry-run. Re-run with --apply to write.');
+  }
+}

package/server/feature-scan.js

@@ -16,6 +16,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import { getTargetRoot, resolveProjectPath } from './project-root.js';
+import { assertValidLinkShape } from '../lib/feature-write-guard.js';
 
 // ---------------------------------------------------------------------------
 // Metadata extraction
@@ -395,6 +396,18 @@ export function writeFeatureGroupToDisk(item, newGroup, featuresDir) {
     spec.updated = new Date().toISOString().slice(0, 10);
   }
 
+  // COMP-MCP-VALIDATE-1: never persist a malformed link shape via the vision
+  // route. Existence (DANGLING) is intentionally NOT checked here: this path
+  // only mutates `group`, so it cannot introduce a new dangling link, and
+  // re-validating existence would wrongly block a group rename on a feature that
+  // already carries a (possibly legitimately forced) forward-ref.
+  try {
+    assertValidLinkShape(spec);
+  } catch (err) {
+    console.warn(`[feature-scan] writeFeatureGroupToDisk: invalid feature.json at ${specPath}, not writing: ${err.message}`);
+    return false;
+  }
+
   try {
     const tmp = path.join(featureDir, `feature.json.tmp.${Date.now()}.${process.pid}`);
     fs.writeFileSync(tmp, JSON.stringify(spec, null, 2) + '\n', 'utf-8');

package/server/graph-export.js

@@ -24,6 +24,7 @@ const STATUS_MAP = {
   parked: 'parked',
   complete: 'complete',
   killed: 'complete',
+  superseded: 'complete',
 };
 
 const EDGE_TYPE_MAP = {

package/server/ideabox-routes.js

@@ -23,6 +23,7 @@ import {
   updateIdea,
   addDiscussion,
 } from '../lib/ideabox.js'
+import { writeFeature } from '../lib/feature-json.js'
 import { IdeaboxCache } from './ideabox-cache.js'
 
 /**
@@ -182,14 +183,15 @@ export function attachIdeaboxRoutes(app, { getProjectRoot, getDataDir, broadcast
       }
       const featuresDir = path.join(projectRoot, featuresRel, resolvedCode)
       if (!fs.existsSync(featuresDir)) {
-        fs.mkdirSync(featuresDir, { recursive: true })
-        fs.writeFileSync(path.join(featuresDir, 'feature.json'), JSON.stringify({
+        // COMP-MCP-VALIDATE-1: route through the validated writer instead of a
+        // raw fs.writeFileSync so the promoted feature.json is schema-guarded.
+        writeFeature(projectRoot, {
           code: resolvedCode,
           description: sourceIdea.title,
           status: 'PLANNED',
           promotedFrom: sourceIdea.id,
           createdAt: new Date().toISOString(),
-        }, null, 2))
+        }, featuresRel)
       }
 
       promoteIdea(parsed, id, resolvedCode)

package/server/vision-store.js

@@ -8,7 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 export const VALID_TYPES = ['feature', 'bug', 'track', 'idea', 'decision', 'question', 'thread', 'artifact', 'task', 'spec', 'evaluation'];
-export const VALID_STATUSES = ['planned', 'ready', 'in_progress', 'review', 'complete', 'blocked', 'parked', 'killed'];
+export const VALID_STATUSES = ['planned', 'ready', 'in_progress', 'review', 'complete', 'blocked', 'parked', 'killed', 'superseded'];
 export const VALID_CONNECTION_TYPES = ['informs', 'blocks', 'supports', 'contradicts', 'implements'];
 export const VALID_PHASES = ['vision', 'specification', 'planning', 'implementation', 'verification', 'release'];
 

package/dist/assets/channel-Bcu04MIK.js

@@ -1 +0,0 @@
-import{ai as o,aj as n}from"./App-CG-2euMe.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/assets/classDiagram-4FO5ZUOK-DU4yxldU.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-727SXJPM-DesUnrEw.js";import{_ as i}from"./App-CG-2euMe.js";import"./chunk-FMBD7UC4-DYHv1PcZ.js";import"./chunk-ND2GUHAM-D0MENOLX.js";import"./chunk-55IACEB6-hMeFx5Nh.js";import"./chunk-2J33WTMH-zMzVB2a6.js";import"./mobile-CG5tLa2S.js";import"./index-B4dv3acY.js";import"./graph-Cs_vqCR0.js";var b={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{b as diagram};

package/dist/assets/classDiagram-v2-Q7XG4LA2-DU4yxldU.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-727SXJPM-DesUnrEw.js";import{_ as i}from"./App-CG-2euMe.js";import"./chunk-FMBD7UC4-DYHv1PcZ.js";import"./chunk-ND2GUHAM-D0MENOLX.js";import"./chunk-55IACEB6-hMeFx5Nh.js";import"./chunk-2J33WTMH-zMzVB2a6.js";import"./mobile-CG5tLa2S.js";import"./index-B4dv3acY.js";import"./graph-Cs_vqCR0.js";var b={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{b as diagram};

package/dist/assets/stateDiagram-v2-BHNVJYJU-BLR6AkKX.js

@@ -1 +0,0 @@
-import{s as r,b as e,a,S as s}from"./chunk-AQP2D5EJ-1uGGvkxW.js";import{_ as i}from"./App-CG-2euMe.js";import"./chunk-55IACEB6-hMeFx5Nh.js";import"./chunk-2J33WTMH-zMzVB2a6.js";import"./mobile-CG5tLa2S.js";import"./index-B4dv3acY.js";import"./graph-Cs_vqCR0.js";var n={parser:a,get db(){return new s(2)},renderer:e,styles:r,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{n as diagram};