@runfusion/fusion 0.25.0 → 0.27.0

package/dist/plugins/fusion-plugin-roadmap/bundled.js

@@ -0,0 +1,1672 @@
+// ../plugin-sdk/src/index.ts
+function definePlugin(plugin2) {
+  return plugin2;
+}
+
+// ../../plugins/fusion-plugin-roadmap/src/store/roadmap-store.js
+import { EventEmitter } from "node:events";
+
+// ../../plugins/fusion-plugin-roadmap/src/store/roadmap-ordering.js
+function compareOrderedEntities(a, b) {
+  if (a.orderIndex !== b.orderIndex) {
+    return a.orderIndex - b.orderIndex;
+  }
+  if (a.createdAt !== b.createdAt) {
+    return a.createdAt.localeCompare(b.createdAt);
+  }
+  return a.id.localeCompare(b.id);
+}
+function clampInsertionIndex(targetIndex, length) {
+  if (!Number.isFinite(targetIndex)) {
+    return length;
+  }
+  const normalized = Math.trunc(targetIndex);
+  if (normalized < 0) {
+    return 0;
+  }
+  if (normalized > length) {
+    return length;
+  }
+  return normalized;
+}
+function assertScopedRoadmapMilestones(milestones, roadmapId) {
+  for (const milestone of milestones) {
+    if (milestone.roadmapId !== roadmapId) {
+      throw new Error(`Milestone ${milestone.id} does not belong to roadmap ${roadmapId}`);
+    }
+  }
+}
+function assertScopedMilestoneFeatures(features, milestoneId) {
+  for (const feature of features) {
+    if (feature.milestoneId !== milestoneId) {
+      throw new Error(`Feature ${feature.id} does not belong to milestone ${milestoneId}`);
+    }
+  }
+}
+function assertScopedMoveFeatures(features, fromMilestoneId, toMilestoneId) {
+  const validMilestoneIds = /* @__PURE__ */ new Set([fromMilestoneId, toMilestoneId]);
+  for (const feature of features) {
+    if (!validMilestoneIds.has(feature.milestoneId)) {
+      throw new Error(`Feature ${feature.id} is outside the affected milestone scope (${fromMilestoneId} \u2192 ${toMilestoneId})`);
+    }
+  }
+}
+function assertExactIdSet(entityLabel, actualIds, orderedIds) {
+  const requestedIds = /* @__PURE__ */ new Set();
+  for (const id of orderedIds) {
+    if (requestedIds.has(id)) {
+      throw new Error(`Duplicate ${entityLabel} id in requested order: ${id}`);
+    }
+    requestedIds.add(id);
+  }
+  if (actualIds.length !== orderedIds.length) {
+    throw new Error(`Expected ${actualIds.length} ${entityLabel} ids but received ${orderedIds.length}`);
+  }
+  const actualIdSet = new Set(actualIds);
+  for (const id of orderedIds) {
+    if (!actualIdSet.has(id)) {
+      throw new Error(`${capitalize(entityLabel)} ${id} not found in scoped list`);
+    }
+  }
+  for (const id of actualIds) {
+    if (!requestedIds.has(id)) {
+      throw new Error(`Missing ${entityLabel} id in requested order: ${id}`);
+    }
+  }
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function assignContiguousOrder(items) {
+  return items.map((item, orderIndex) => {
+    if (item.orderIndex === orderIndex) {
+      return { ...item };
+    }
+    return {
+      ...item,
+      orderIndex
+    };
+  });
+}
+function normalizeRoadmapMilestoneOrder(milestones) {
+  if (milestones.length === 0) {
+    return [];
+  }
+  assertScopedRoadmapMilestones(milestones, milestones[0].roadmapId);
+  return assignContiguousOrder([...milestones].sort(compareOrderedEntities));
+}
+function applyRoadmapMilestoneReorder(milestones, input) {
+  assertScopedRoadmapMilestones(milestones, input.roadmapId);
+  const normalized = normalizeRoadmapMilestoneOrder(milestones);
+  const ids = normalized.map((milestone) => milestone.id);
+  assertExactIdSet("milestone", ids, input.orderedMilestoneIds);
+  const byId = new Map(normalized.map((milestone) => [milestone.id, milestone]));
+  return assignContiguousOrder(input.orderedMilestoneIds.map((id) => byId.get(id)));
+}
+function normalizeRoadmapFeatureOrder(features) {
+  if (features.length === 0) {
+    return [];
+  }
+  assertScopedMilestoneFeatures(features, features[0].milestoneId);
+  return assignContiguousOrder([...features].sort(compareOrderedEntities));
+}
+function applyRoadmapFeatureReorder(features, input) {
+  assertScopedMilestoneFeatures(features, input.milestoneId);
+  const normalized = normalizeRoadmapFeatureOrder(features);
+  const ids = normalized.map((feature) => feature.id);
+  assertExactIdSet("feature", ids, input.orderedFeatureIds);
+  const byId = new Map(normalized.map((feature) => [feature.id, feature]));
+  return assignContiguousOrder(input.orderedFeatureIds.map((id) => byId.get(id)));
+}
+function moveRoadmapFeature(features, input) {
+  assertScopedMoveFeatures(features, input.fromMilestoneId, input.toMilestoneId);
+  const existingFeature = features.find((feature) => feature.id === input.featureId);
+  if (!existingFeature) {
+    throw new Error(`Feature ${input.featureId} not found in affected milestone scope`);
+  }
+  if (existingFeature.milestoneId !== input.fromMilestoneId) {
+    throw new Error(`Feature ${input.featureId} does not belong to milestone ${input.fromMilestoneId}`);
+  }
+  const sourceFeatures = normalizeRoadmapFeatureOrder(features.filter((feature) => feature.milestoneId === input.fromMilestoneId));
+  const sourceWithoutFeature = sourceFeatures.filter((feature) => feature.id !== input.featureId);
+  if (input.fromMilestoneId === input.toMilestoneId) {
+    const insertionIndex2 = clampInsertionIndex(input.targetOrderIndex, sourceWithoutFeature.length);
+    const reordered = [...sourceWithoutFeature];
+    reordered.splice(insertionIndex2, 0, {
+      ...existingFeature,
+      milestoneId: input.toMilestoneId,
+      orderIndex: insertionIndex2
+    });
+    const normalized = assignContiguousOrder(reordered);
+    const movedFeature2 = normalized.find((feature) => feature.id === input.featureId);
+    return {
+      movedFeature: movedFeature2,
+      affectedFeatures: normalized,
+      sourceMilestoneFeatures: normalized,
+      targetMilestoneFeatures: normalized
+    };
+  }
+  const targetFeatures = normalizeRoadmapFeatureOrder(features.filter((feature) => feature.milestoneId === input.toMilestoneId));
+  const insertionIndex = clampInsertionIndex(input.targetOrderIndex, targetFeatures.length);
+  const targetWithInsertedFeature = [...targetFeatures];
+  targetWithInsertedFeature.splice(insertionIndex, 0, {
+    ...existingFeature,
+    milestoneId: input.toMilestoneId,
+    orderIndex: insertionIndex
+  });
+  const normalizedSource = assignContiguousOrder(sourceWithoutFeature);
+  const normalizedTarget = assignContiguousOrder(targetWithInsertedFeature);
+  const movedFeature = normalizedTarget.find((feature) => feature.id === input.featureId);
+  return {
+    movedFeature,
+    affectedFeatures: [...normalizedSource, ...normalizedTarget],
+    sourceMilestoneFeatures: normalizedSource,
+    targetMilestoneFeatures: normalizedTarget
+  };
+}
+
+// ../../plugins/fusion-plugin-roadmap/src/store/roadmap-store.js
+var RoadmapStore = class extends EventEmitter {
+  db;
+  /**
+   * Creates a new RoadmapStore instance.
+   *
+   * @param db - Shared Database instance (same instance used by TaskStore)
+   */
+  constructor(db) {
+    super();
+    this.db = db;
+    this.setMaxListeners(50);
+    this.ensureSchema();
+  }
+  ensureSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS roadmaps (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        description TEXT,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS roadmap_milestones (
+        id TEXT PRIMARY KEY,
+        roadmapId TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT,
+        orderIndex INTEGER NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        FOREIGN KEY (roadmapId) REFERENCES roadmaps(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS roadmap_features (
+        id TEXT PRIMARY KEY,
+        milestoneId TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT,
+        orderIndex INTEGER NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        FOREIGN KEY (milestoneId) REFERENCES roadmap_milestones(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idxRoadmapMilestonesRoadmapOrder
+        ON roadmap_milestones(roadmapId, orderIndex, createdAt, id);
+
+      CREATE INDEX IF NOT EXISTS idxRoadmapFeaturesMilestoneOrder
+        ON roadmap_features(milestoneId, orderIndex, createdAt, id);
+    `);
+  }
+  // ── ID Generators ───────────────────────────────────────────────────
+  generateRoadmapId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 6).toUpperCase();
+    return `RM-${timestamp.toString(36).toUpperCase()}-${random}`;
+  }
+  generateMilestoneId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 6).toUpperCase();
+    return `RMS-${timestamp.toString(36).toUpperCase()}-${random}`;
+  }
+  generateFeatureId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 6).toUpperCase();
+    return `RF-${timestamp.toString(36).toUpperCase()}-${random}`;
+  }
+  // ── Row-to-Object Converters ───────────────────────────────────────
+  rowToRoadmap(row) {
+    return {
+      id: row.id,
+      title: row.title,
+      description: row.description || void 0,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  rowToMilestone(row) {
+    return {
+      id: row.id,
+      roadmapId: row.roadmapId,
+      title: row.title,
+      description: row.description || void 0,
+      orderIndex: row.orderIndex,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  rowToFeature(row) {
+    return {
+      id: row.id,
+      milestoneId: row.milestoneId,
+      title: row.title,
+      description: row.description || void 0,
+      orderIndex: row.orderIndex,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  // ── Roadmap CRUD ─────────────────────────────────────────────────
+  /**
+   * Create a new roadmap.
+   *
+   * @param input - Roadmap creation input
+   * @returns The created roadmap
+   */
+  createRoadmap(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = this.generateRoadmapId();
+    const roadmap = {
+      id,
+      title: input.title,
+      description: input.description,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.prepare(`
+      INSERT INTO roadmaps (id, title, description, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(roadmap.id, roadmap.title, roadmap.description ?? null, roadmap.createdAt, roadmap.updatedAt);
+    this.db.bumpLastModified();
+    this.emit("roadmap:created", roadmap);
+    return roadmap;
+  }
+  /**
+   * Get a roadmap by ID.
+   *
+   * @param id - Roadmap ID
+   * @returns The roadmap, or undefined if not found
+   */
+  getRoadmap(id) {
+    const row = this.db.prepare("SELECT * FROM roadmaps WHERE id = ?").get(id);
+    if (!row)
+      return void 0;
+    return this.rowToRoadmap(row);
+  }
+  /**
+   * List all roadmaps, ordered by creation date (newest first).
+   *
+   * @returns Array of roadmaps
+   */
+  listRoadmaps() {
+    const rows = this.db.prepare("SELECT * FROM roadmaps ORDER BY createdAt DESC").all();
+    return rows.map((row) => this.rowToRoadmap(row));
+  }
+  /**
+   * Update a roadmap.
+   *
+   * @param id - Roadmap ID
+   * @param updates - Partial roadmap updates
+   * @returns The updated roadmap
+   * @throws Error if roadmap not found
+   */
+  updateRoadmap(id, updates) {
+    const roadmap = this.getRoadmap(id);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${id} not found`);
+    }
+    const updated = {
+      ...roadmap,
+      ...updates,
+      id,
+      // Prevent changing ID
+      createdAt: roadmap.createdAt,
+      // Prevent changing creation time
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.db.prepare(`
+      UPDATE roadmaps SET
+        title = ?,
+        description = ?,
+        updatedAt = ?
+      WHERE id = ?
+    `).run(updated.title, updated.description ?? null, updated.updatedAt, updated.id);
+    this.db.bumpLastModified();
+    this.emit("roadmap:updated", updated);
+    return updated;
+  }
+  /**
+   * Delete a roadmap and all its milestones/features (cascading).
+   *
+   * @param id - Roadmap ID
+   * @throws Error if roadmap not found
+   */
+  deleteRoadmap(id) {
+    const roadmap = this.getRoadmap(id);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${id} not found`);
+    }
+    this.db.prepare("DELETE FROM roadmaps WHERE id = ?").run(id);
+    this.db.bumpLastModified();
+    this.emit("roadmap:deleted", id);
+  }
+  // ── Milestone CRUD ────────────────────────────────────────────────
+  /**
+   * Add a milestone to a roadmap.
+   * Automatically computes the orderIndex (max + 1).
+   *
+   * @param roadmapId - Parent roadmap ID
+   * @param input - Milestone creation input
+   * @returns The created milestone
+   * @throws Error if roadmap not found
+   */
+  createMilestone(roadmapId, input) {
+    const roadmap = this.getRoadmap(roadmapId);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${roadmapId} not found`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = this.generateMilestoneId();
+    const existingMilestones = this.listMilestones(roadmapId);
+    const orderIndex = existingMilestones.length > 0 ? Math.max(...existingMilestones.map((m) => m.orderIndex)) + 1 : 0;
+    const milestone = {
+      id,
+      roadmapId,
+      title: input.title,
+      description: input.description,
+      orderIndex,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.prepare(`
+      INSERT INTO roadmap_milestones (id, roadmapId, title, description, orderIndex, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(milestone.id, milestone.roadmapId, milestone.title, milestone.description ?? null, milestone.orderIndex, milestone.createdAt, milestone.updatedAt);
+    this.db.bumpLastModified();
+    this.emit("milestone:created", milestone);
+    return milestone;
+  }
+  /**
+   * Get a milestone by ID.
+   *
+   * @param id - Milestone ID
+   * @returns The milestone, or undefined if not found
+   */
+  getMilestone(id) {
+    const row = this.db.prepare("SELECT * FROM roadmap_milestones WHERE id = ?").get(id);
+    if (!row)
+      return void 0;
+    return this.rowToMilestone(row);
+  }
+  /**
+   * List milestones for a roadmap, ordered deterministically.
+   *
+   * Uses deterministic ordering: ORDER BY orderIndex ASC, createdAt ASC, id ASC
+   * to ensure consistent results when stored order data is incomplete or conflicting.
+   *
+   * @param roadmapId - Roadmap ID
+   * @returns Array of milestones in deterministic order
+   */
+  listMilestones(roadmapId) {
+    const rows = this.db.prepare("SELECT * FROM roadmap_milestones WHERE roadmapId = ? ORDER BY orderIndex ASC, createdAt ASC, id ASC").all(roadmapId);
+    return rows.map((row) => this.rowToMilestone(row));
+  }
+  /**
+   * Update a milestone.
+   *
+   * @param id - Milestone ID
+   * @param updates - Partial milestone updates
+   * @returns The updated milestone
+   * @throws Error if milestone not found
+   */
+  updateMilestone(id, updates) {
+    const milestone = this.getMilestone(id);
+    if (!milestone) {
+      throw new Error(`Milestone ${id} not found`);
+    }
+    const updated = {
+      ...milestone,
+      ...updates,
+      id,
+      // Prevent changing ID
+      roadmapId: milestone.roadmapId,
+      // Prevent moving to different roadmap
+      createdAt: milestone.createdAt,
+      // Prevent changing creation time
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.db.prepare(`
+      UPDATE roadmap_milestones SET
+        title = ?,
+        description = ?,
+        updatedAt = ?
+      WHERE id = ?
+    `).run(updated.title, updated.description ?? null, updated.updatedAt, updated.id);
+    this.db.bumpLastModified();
+    this.emit("milestone:updated", updated);
+    return updated;
+  }
+  /**
+   * Delete a milestone and all its features (cascading).
+   *
+   * @param id - Milestone ID
+   * @throws Error if milestone not found
+   */
+  deleteMilestone(id) {
+    const milestone = this.getMilestone(id);
+    if (!milestone) {
+      throw new Error(`Milestone ${id} not found`);
+    }
+    this.db.prepare("DELETE FROM roadmap_milestones WHERE id = ?").run(id);
+    this.db.bumpLastModified();
+    this.emit("milestone:deleted", id);
+  }
+  // ── Feature CRUD ─────────────────────────────────────────────────
+  /**
+   * Add a feature to a milestone.
+   * Automatically computes the orderIndex (max + 1).
+   *
+   * @param milestoneId - Parent milestone ID
+   * @param input - Feature creation input
+   * @returns The created feature
+   * @throws Error if milestone not found
+   */
+  createFeature(milestoneId, input) {
+    const milestone = this.getMilestone(milestoneId);
+    if (!milestone) {
+      throw new Error(`Milestone ${milestoneId} not found`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = this.generateFeatureId();
+    const existingFeatures = this.listFeatures(milestoneId);
+    const orderIndex = existingFeatures.length > 0 ? Math.max(...existingFeatures.map((f) => f.orderIndex)) + 1 : 0;
+    const feature = {
+      id,
+      milestoneId,
+      title: input.title,
+      description: input.description,
+      orderIndex,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.prepare(`
+      INSERT INTO roadmap_features (id, milestoneId, title, description, orderIndex, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(feature.id, feature.milestoneId, feature.title, feature.description ?? null, feature.orderIndex, feature.createdAt, feature.updatedAt);
+    this.db.bumpLastModified();
+    this.emit("feature:created", feature);
+    return feature;
+  }
+  /**
+   * Get a feature by ID.
+   *
+   * @param id - Feature ID
+   * @returns The feature, or undefined if not found
+   */
+  getFeature(id) {
+    const row = this.db.prepare("SELECT * FROM roadmap_features WHERE id = ?").get(id);
+    if (!row)
+      return void 0;
+    return this.rowToFeature(row);
+  }
+  /**
+   * List features for a milestone, ordered deterministically.
+   *
+   * Uses deterministic ordering: ORDER BY orderIndex ASC, createdAt ASC, id ASC
+   * to ensure consistent results when stored order data is incomplete or conflicting.
+   *
+   * @param milestoneId - Milestone ID
+   * @returns Array of features in deterministic order
+   */
+  listFeatures(milestoneId) {
+    const rows = this.db.prepare("SELECT * FROM roadmap_features WHERE milestoneId = ? ORDER BY orderIndex ASC, createdAt ASC, id ASC").all(milestoneId);
+    return rows.map((row) => this.rowToFeature(row));
+  }
+  /**
+   * Update a feature.
+   *
+   * @param id - Feature ID
+   * @param updates - Partial feature updates
+   * @returns The updated feature
+   * @throws Error if feature not found
+   */
+  updateFeature(id, updates) {
+    const feature = this.getFeature(id);
+    if (!feature) {
+      throw new Error(`Feature ${id} not found`);
+    }
+    const updated = {
+      ...feature,
+      ...updates,
+      id,
+      // Prevent changing ID
+      milestoneId: feature.milestoneId,
+      // Prevent moving via update (use moveFeature instead)
+      createdAt: feature.createdAt,
+      // Prevent changing creation time
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.db.prepare(`
+      UPDATE roadmap_features SET
+        title = ?,
+        description = ?,
+        updatedAt = ?
+      WHERE id = ?
+    `).run(updated.title, updated.description ?? null, updated.updatedAt, updated.id);
+    this.db.bumpLastModified();
+    this.emit("feature:updated", updated);
+    return updated;
+  }
+  /**
+   * Delete a feature.
+   *
+   * @param id - Feature ID
+   * @throws Error if feature not found
+   */
+  deleteFeature(id) {
+    const feature = this.getFeature(id);
+    if (!feature) {
+      throw new Error(`Feature ${id} not found`);
+    }
+    this.db.prepare("DELETE FROM roadmap_features WHERE id = ?").run(id);
+    this.db.bumpLastModified();
+    this.emit("feature:deleted", feature);
+  }
+  // ── Reorder Operations ────────────────────────────────────────────
+  /**
+   * Reorder milestones within a roadmap.
+   *
+   * Applies an explicit reorder input and persists the full normalized order.
+   * The input must contain all milestone IDs exactly once.
+   *
+   * @param input - Reorder input with complete milestone ID list
+   * @returns The reordered milestones in their new order
+   * @throws Error if milestone set is incomplete, duplicate, or not found
+   */
+  reorderMilestones(input) {
+    const roadmap = this.getRoadmap(input.roadmapId);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${input.roadmapId} not found`);
+    }
+    const milestones = this.listMilestones(input.roadmapId);
+    const reordered = applyRoadmapMilestoneReorder(milestones, input);
+    this.db.transaction(() => {
+      for (const milestone of reordered) {
+        this.db.prepare(`
+          UPDATE roadmap_milestones SET orderIndex = ?, updatedAt = ? WHERE id = ?
+        `).run(milestone.orderIndex, (/* @__PURE__ */ new Date()).toISOString(), milestone.id);
+      }
+    });
+    this.db.bumpLastModified();
+    this.emit("milestone:reordered", { roadmapId: input.roadmapId, milestones: reordered });
+    return reordered;
+  }
+  /**
+   * Reorder features within a milestone.
+   *
+   * Applies an explicit reorder input and persists the full normalized order.
+   * The input must contain all feature IDs for the milestone exactly once.
+   *
+   * @param input - Reorder input with complete feature ID list
+   * @returns The reordered features in their new order
+   * @throws Error if feature set is incomplete, duplicate, or not found
+   */
+  reorderFeatures(input) {
+    const milestone = this.getMilestone(input.milestoneId);
+    if (!milestone) {
+      throw new Error(`Milestone ${input.milestoneId} not found`);
+    }
+    if (milestone.roadmapId !== input.roadmapId) {
+      throw new Error(`Milestone ${input.milestoneId} does not belong to roadmap ${input.roadmapId}`);
+    }
+    const features = this.listFeatures(input.milestoneId);
+    const reordered = applyRoadmapFeatureReorder(features, input);
+    this.db.transaction(() => {
+      for (const feature of reordered) {
+        this.db.prepare(`
+          UPDATE roadmap_features SET orderIndex = ?, updatedAt = ? WHERE id = ?
+        `).run(feature.orderIndex, (/* @__PURE__ */ new Date()).toISOString(), feature.id);
+      }
+    });
+    this.db.bumpLastModified();
+    this.emit("feature:reordered", { milestoneId: input.milestoneId, features: reordered });
+    return reordered;
+  }
+  /**
+   * Move a feature, including cross-milestone moves.
+   *
+   * Atomically renumbers both the source and destination milestone scopes.
+   *
+   * @param input - Move input with source/destination milestone info
+   * @returns The moved feature and both affected milestone feature lists
+   * @throws Error if feature or milestone not found, or scope validation fails
+   */
+  moveFeature(input) {
+    const roadmap = this.getRoadmap(input.roadmapId);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${input.roadmapId} not found`);
+    }
+    const fromMilestone = this.getMilestone(input.fromMilestoneId);
+    const toMilestone = this.getMilestone(input.toMilestoneId);
+    if (!fromMilestone) {
+      throw new Error(`Source milestone ${input.fromMilestoneId} not found`);
+    }
+    if (!toMilestone) {
+      throw new Error(`Destination milestone ${input.toMilestoneId} not found`);
+    }
+    if (fromMilestone.roadmapId !== input.roadmapId) {
+      throw new Error(`Source milestone ${input.fromMilestoneId} does not belong to roadmap ${input.roadmapId}`);
+    }
+    if (toMilestone.roadmapId !== input.roadmapId) {
+      throw new Error(`Destination milestone ${input.toMilestoneId} does not belong to roadmap ${input.roadmapId}`);
+    }
+    const sourceFeatures = this.listFeatures(input.fromMilestoneId);
+    const targetFeatures = this.listFeatures(input.toMilestoneId);
+    const allFeatures = input.fromMilestoneId === input.toMilestoneId ? sourceFeatures : [...sourceFeatures, ...targetFeatures];
+    const result = moveRoadmapFeature(allFeatures, input);
+    this.db.transaction(() => {
+      for (const feature of result.affectedFeatures) {
+        this.db.prepare(`
+          UPDATE roadmap_features SET milestoneId = ?, orderIndex = ?, updatedAt = ? WHERE id = ?
+        `).run(feature.milestoneId, feature.orderIndex, (/* @__PURE__ */ new Date()).toISOString(), feature.id);
+      }
+    });
+    this.db.bumpLastModified();
+    this.emit("feature:moved", {
+      feature: result.movedFeature,
+      fromMilestoneId: input.fromMilestoneId,
+      toMilestoneId: input.toMilestoneId
+    });
+    return {
+      movedFeature: result.movedFeature,
+      sourceMilestoneFeatures: result.sourceMilestoneFeatures,
+      targetMilestoneFeatures: result.targetMilestoneFeatures
+    };
+  }
+  // ── Hierarchy Operations ───────────────────────────────────────────
+  /**
+   * Get a milestone with all of its features in deterministic order.
+   *
+   * @param id - Milestone ID
+   * @returns The milestone with features, or undefined if not found
+   */
+  getMilestoneWithFeatures(id) {
+    const milestone = this.getMilestone(id);
+    if (!milestone)
+      return void 0;
+    return {
+      ...milestone,
+      features: this.listFeatures(id)
+    };
+  }
+  /**
+   * Get a roadmap with its full hierarchy (milestones → features).
+   *
+   * @param id - Roadmap ID
+   * @returns The roadmap with hierarchy, or undefined if not found
+   */
+  getRoadmapWithHierarchy(id) {
+    const roadmap = this.getRoadmap(id);
+    if (!roadmap)
+      return void 0;
+    return {
+      ...roadmap,
+      milestones: this.listMilestones(id).map((milestone) => ({
+        ...milestone,
+        features: this.listFeatures(milestone.id)
+      }))
+    };
+  }
+  // ── Export / Handoff Operations ────────────────────────────────────
+  /**
+   * Get a flat export bundle for a roadmap.
+   *
+   * Returns all roadmap data in a flat structure suitable for persistence,
+   * APIs, import/export, and sync jobs. Entities are separated so downstream
+   * persistence layers can upsert by table/collection.
+   *
+   * @param roadmapId - Roadmap ID
+   * @returns The export bundle with ordered entities
+   * @throws Error if roadmap not found
+   */
+  getRoadmapExport(roadmapId) {
+    const roadmap = this.getRoadmap(roadmapId);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${roadmapId} not found`);
+    }
+    const milestones = this.listMilestones(roadmapId);
+    const allFeatures = [];
+    for (const milestone of milestones) {
+      const features = this.listFeatures(milestone.id);
+      allFeatures.push(...features);
+    }
+    return {
+      roadmap,
+      milestones,
+      features: allFeatures
+    };
+  }
+  /**
+   * Get a mission planning handoff payload for a roadmap.
+   *
+   * Converts the roadmap into a mission planning structure while preserving
+   * source IDs and deterministic order. Does not couple to MissionStore internals.
+   *
+   * @param roadmapId - Roadmap ID
+   * @returns The mission planning handoff payload
+   * @throws Error if roadmap not found
+   */
+  getRoadmapMissionHandoff(roadmapId) {
+    const roadmap = this.getRoadmap(roadmapId);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${roadmapId} not found`);
+    }
+    const milestones = this.listMilestones(roadmapId);
+    return {
+      sourceRoadmapId: roadmap.id,
+      title: roadmap.title,
+      description: roadmap.description,
+      milestones: milestones.map((milestone) => {
+        const features = this.listFeatures(milestone.id);
+        return {
+          sourceMilestoneId: milestone.id,
+          title: milestone.title,
+          description: milestone.description,
+          orderIndex: milestone.orderIndex,
+          features: features.map((feature) => ({
+            sourceFeatureId: feature.id,
+            title: feature.title,
+            description: feature.description,
+            orderIndex: feature.orderIndex
+          }))
+        };
+      })
+    };
+  }
+  /**
+   * Get a task planning handoff payload for a single roadmap feature.
+   *
+   * Returns a self-contained handoff payload for converting a roadmap feature
+   * into task planning flows without coupling to MissionStore internals.
+   *
+   * @param roadmapId - Parent roadmap ID (for validation)
+   * @param milestoneId - Parent milestone ID (for validation)
+   * @param featureId - Feature ID to generate handoff for
+   * @returns The task planning handoff payload
+   * @throws Error if any entity is not found or if ownership validation fails
+   */
+  getRoadmapFeatureHandoff(roadmapId, milestoneId, featureId) {
+    const roadmap = this.getRoadmap(roadmapId);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${roadmapId} not found`);
+    }
+    const milestone = this.getMilestone(milestoneId);
+    if (!milestone) {
+      throw new Error(`Milestone ${milestoneId} not found`);
+    }
+    if (milestone.roadmapId !== roadmapId) {
+      throw new Error(`Milestone ${milestoneId} does not belong to roadmap ${roadmapId}`);
+    }
+    const feature = this.getFeature(featureId);
+    if (!feature) {
+      throw new Error(`Feature ${featureId} not found`);
+    }
+    if (feature.milestoneId !== milestoneId) {
+      throw new Error(`Feature ${featureId} does not belong to milestone ${milestoneId}`);
+    }
+    const source = {
+      roadmapId: roadmap.id,
+      milestoneId: milestone.id,
+      featureId: feature.id,
+      roadmapTitle: roadmap.title,
+      milestoneTitle: milestone.title,
+      milestoneOrderIndex: milestone.orderIndex,
+      featureOrderIndex: feature.orderIndex
+    };
+    return {
+      source,
+      title: feature.title,
+      description: feature.description
+    };
+  }
+  /**
+   * Get a mission planning handoff payload for a roadmap.
+   *
+   * Alias for getRoadmapMissionHandoff() for API consistency.
+   * Converts the roadmap into a mission planning structure while preserving
+   * source IDs and deterministic order.
+   *
+   * @param roadmapId - Roadmap ID
+   * @returns The mission planning handoff payload
+   * @throws Error if roadmap not found
+   */
+  getMissionPlanningHandoff(roadmapId) {
+    return this.getRoadmapMissionHandoff(roadmapId);
+  }
+  /**
+   * List all task planning handoff payloads for a roadmap.
+   *
+   * Returns a flat list of all feature handoffs in deterministic order
+   * (milestone order index, then feature order index).
+   *
+   * @param roadmapId - Roadmap ID
+   * @returns Array of task planning handoff payloads for all features
+   * @throws Error if roadmap not found
+   */
+  listFeatureTaskPlanningHandoffs(roadmapId) {
+    const roadmap = this.getRoadmap(roadmapId);
+    if (!roadmap) {
+      throw new Error(`Roadmap ${roadmapId} not found`);
+    }
+    const milestones = this.listMilestones(roadmapId);
+    const handoffs = [];
+    for (const milestone of milestones) {
+      const features = this.listFeatures(milestone.id);
+      for (const feature of features) {
+        const source = {
+          roadmapId: roadmap.id,
+          milestoneId: milestone.id,
+          featureId: feature.id,
+          roadmapTitle: roadmap.title,
+          milestoneTitle: milestone.title,
+          milestoneOrderIndex: milestone.orderIndex,
+          featureOrderIndex: feature.orderIndex
+        };
+        handoffs.push({
+          source,
+          title: feature.title,
+          description: feature.description
+        });
+      }
+    }
+    return handoffs;
+  }
+};
+
+// ../../plugins/fusion-plugin-roadmap/src/routes/roadmap-suggestions.js
+var injectedCreateAiSession;
+var MILESTONE_SUGGESTION_SYSTEM_PROMPT = `You are a milestone planning assistant for a product roadmap system.
+
+Your job is to suggest logical milestones that would help achieve a user's roadmap goal.
+
+## Guidelines
+
+1. **Think about phases**: Break the goal into logical phases
+2. **Use clear titles**: Milestone titles should be concise and descriptive
+3. **Add context**: Include a brief description explaining what this milestone encompasses
+4. **Order matters**: List milestones in the order they should be completed
+5. **Realistic scope**: Each milestone should be achievable in 2-4 weeks
+
+## Output Format
+
+Respond with ONLY a valid JSON array of milestone suggestions.`;
+var MAX_GOAL_PROMPT_LENGTH = 4e3;
+var SUGGESTION_TIMEOUT_MS = 12e4;
+var DEFAULT_SUGGESTION_COUNT = 5;
+var MAX_SUGGESTION_COUNT = 10;
+var MIN_SUGGESTION_COUNT = 1;
+var MAX_PARSE_RETRIES = 1;
+function validateSuggestionInput(input) {
+  if (!input || typeof input !== "object") {
+    throw new ValidationError("Request body must be an object");
+  }
+  const { goalPrompt, count } = input;
+  if (typeof goalPrompt !== "string" || !goalPrompt.trim()) {
+    throw new ValidationError("goalPrompt is required and must be a non-empty string");
+  }
+  if (goalPrompt.length > MAX_GOAL_PROMPT_LENGTH) {
+    throw new ValidationError(`goalPrompt exceeds maximum length of ${MAX_GOAL_PROMPT_LENGTH} characters`);
+  }
+  if (count !== void 0) {
+    if (typeof count !== "number" || !Number.isInteger(count))
+      throw new ValidationError("count must be an integer");
+    if (count < MIN_SUGGESTION_COUNT || count > MAX_SUGGESTION_COUNT) {
+      throw new ValidationError(`count must be between ${MIN_SUGGESTION_COUNT} and ${MAX_SUGGESTION_COUNT}`);
+    }
+  }
+}
+function extractJsonCandidate(text) {
+  if (!text || !text.trim())
+    return null;
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  const source = codeBlockMatch?.[1]?.trim() || text.trim();
+  const startIndex = source.indexOf("[");
+  if (startIndex < 0)
+    return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = startIndex; index < source.length; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "[")
+      depth++;
+    if (char === "]") {
+      depth--;
+      if (depth === 0) {
+        return source.slice(startIndex, index + 1).trim();
+      }
+    }
+  }
+  return source.slice(startIndex).trim();
+}
+function repairJson(text) {
+  let repaired = text.replace(/,\s*([}\]])/g, "$1");
+  let depthBraces = 0;
+  let depthBrackets = 0;
+  for (const ch of repaired) {
+    if (ch === "{")
+      depthBraces++;
+    if (ch === "}")
+      depthBraces--;
+    if (ch === "[")
+      depthBrackets++;
+    if (ch === "]")
+      depthBrackets--;
+  }
+  repaired += "]".repeat(Math.max(0, depthBrackets));
+  repaired += "}".repeat(Math.max(0, depthBraces));
+  return repaired;
+}
+function parseMilestoneSuggestions(text) {
+  const candidate = extractJsonCandidate(text);
+  if (!candidate)
+    throw new ParseError("AI returned no valid JSON. Please try again.");
+  let parsed;
+  try {
+    parsed = JSON.parse(candidate);
+  } catch {
+    parsed = JSON.parse(repairJson(candidate));
+  }
+  if (!Array.isArray(parsed)) {
+    throw new ParseError("AI response must be a JSON array of milestone suggestions");
+  }
+  const suggestions = [];
+  for (const item of parsed) {
+    if (!item || typeof item !== "object")
+      continue;
+    const row = item;
+    if (typeof row.title !== "string" || !row.title.trim())
+      continue;
+    suggestions.push({
+      title: row.title.trim(),
+      description: typeof row.description === "string" && row.description.trim() ? row.description.trim() : void 0
+    });
+  }
+  if (suggestions.length === 0)
+    throw new ParseError("AI returned no valid milestone suggestions");
+  return suggestions;
+}
+function pickFactory(explicit) {
+  return explicit ?? injectedCreateAiSession;
+}
+async function runPrompt(createAiSession, options, prompt) {
+  const agent = await createAiSession(options);
+  await agent.session.prompt(prompt);
+  const lastMessage = agent.session.state.messages.filter((m) => m.role === "assistant").pop();
+  let text = "";
+  if (lastMessage?.content) {
+    if (typeof lastMessage.content === "string")
+      text = lastMessage.content;
+    else {
+      text = lastMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+    }
+  }
+  return { text, dispose: agent.session.dispose };
+}
+async function generateMilestoneSuggestions(goalPrompt, count = DEFAULT_SUGGESTION_COUNT, rootDir, modelProvider, modelId, createAiSession) {
+  const factory = pickFactory(createAiSession);
+  if (!factory)
+    throw new ServiceUnavailableError("AI service is not available");
+  if (!rootDir)
+    throw new Error("rootDir is required for AI-powered suggestion generation");
+  const result = await Promise.race([
+    (async () => {
+      let dispose;
+      try {
+        let response = await runPrompt(factory, {
+          cwd: rootDir,
+          systemPrompt: MILESTONE_SUGGESTION_SYSTEM_PROMPT,
+          tools: "readonly",
+          ...modelProvider && modelId ? { defaultProvider: modelProvider, defaultModelId: modelId } : {}
+        }, `Please suggest ${count} milestones for the following roadmap goal:
+
+${goalPrompt.trim()}`);
+        dispose = response.dispose;
+        let suggestions;
+        let lastError;
+        for (let attempt = 0; attempt <= MAX_PARSE_RETRIES; attempt++) {
+          try {
+            suggestions = parseMilestoneSuggestions(response.text);
+            break;
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt === MAX_PARSE_RETRIES)
+              break;
+            response = await runPrompt(factory, {
+              cwd: rootDir,
+              systemPrompt: MILESTONE_SUGGESTION_SYSTEM_PROMPT,
+              tools: "readonly",
+              ...modelProvider && modelId ? { defaultProvider: modelProvider, defaultModelId: modelId } : {}
+            }, "Your previous response could not be parsed as JSON. Respond with only a JSON array.");
+            dispose = response.dispose;
+          }
+        }
+        if (!suggestions) {
+          throw new ParseError(`Failed to parse AI response after ${MAX_PARSE_RETRIES + 1} attempts: ${lastError?.message ?? "Unknown error"}`);
+        }
+        return suggestions.slice(0, count);
+      } finally {
+        dispose?.();
+      }
+    })(),
+    new Promise((_, reject) => globalThis.setTimeout(() => reject(new ServiceUnavailableError("AI suggestion generation timed out. Please try again.")), SUGGESTION_TIMEOUT_MS))
+  ]);
+  return result;
+}
+var FEATURE_SUGGESTION_SYSTEM_PROMPT = `You are a feature planning assistant for a product roadmap system.`;
+var MAX_FEATURE_PROMPT_LENGTH = 2e3;
+function validateFeatureSuggestionInput(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new ValidationError("Request body must be an object");
+  const { prompt, count } = input;
+  if (prompt !== void 0) {
+    if (typeof prompt !== "string")
+      throw new ValidationError("prompt must be a string");
+    if (prompt.length > MAX_FEATURE_PROMPT_LENGTH)
+      throw new ValidationError(`prompt exceeds maximum length of ${MAX_FEATURE_PROMPT_LENGTH} characters`);
+  }
+  if (count !== void 0) {
+    if (typeof count !== "number" || !Number.isInteger(count))
+      throw new ValidationError("count must be an integer");
+    if (count < MIN_SUGGESTION_COUNT || count > MAX_SUGGESTION_COUNT) {
+      throw new ValidationError(`count must be between ${MIN_SUGGESTION_COUNT} and ${MAX_SUGGESTION_COUNT}`);
+    }
+  }
+}
+function buildMilestoneContextString(context) {
+  const lines = [];
+  lines.push(`Roadmap: ${context.roadmapTitle}`);
+  if (context.roadmapDescription)
+    lines.push(`Description: ${context.roadmapDescription}`);
+  lines.push("", `Milestone: ${context.milestoneTitle}`);
+  if (context.milestoneDescription)
+    lines.push(`Description: ${context.milestoneDescription}`);
+  if (context.existingFeatureTitles.length > 0) {
+    lines.push("", "Existing features in this milestone:");
+    for (const title of context.existingFeatureTitles)
+      lines.push(`  - ${title}`);
+  }
+  return lines.join("\n");
+}
+function parseFeatureSuggestions(text) {
+  return parseMilestoneSuggestions(text);
+}
+async function generateFeatureSuggestions(context, count = DEFAULT_SUGGESTION_COUNT, prompt, rootDir, modelProvider, modelId, createAiSession) {
+  const factory = pickFactory(createAiSession);
+  if (!factory)
+    throw new ServiceUnavailableError("AI service is not available");
+  if (!rootDir)
+    throw new Error("rootDir is required for AI-powered suggestion generation");
+  const systemPrompt = `${FEATURE_SUGGESTION_SYSTEM_PROMPT}
+
+${buildMilestoneContextString(context)}`;
+  const userMessage = prompt?.trim() ? `Please suggest ${count} features for the milestone described above.
+
+Additional guidance:
+${prompt.trim()}` : `Please suggest ${count} features for the milestone described above.`;
+  const result = await Promise.race([
+    (async () => {
+      const { text, dispose } = await runPrompt(factory, {
+        cwd: rootDir,
+        systemPrompt,
+        tools: "readonly",
+        ...modelProvider && modelId ? { defaultProvider: modelProvider, defaultModelId: modelId } : {}
+      }, userMessage);
+      try {
+        return parseFeatureSuggestions(text).slice(0, count);
+      } finally {
+        dispose?.();
+      }
+    })(),
+    new Promise((_, reject) => globalThis.setTimeout(() => reject(new ServiceUnavailableError("AI suggestion generation timed out. Please try again.")), SUGGESTION_TIMEOUT_MS))
+  ]);
+  return result;
+}
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var ParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParseError";
+  }
+};
+var ServiceUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ServiceUnavailableError";
+  }
+};
+
+// ../../plugins/fusion-plugin-roadmap/src/routes/roadmap-routes.js
+var roadmapStoreCache = /* @__PURE__ */ new WeakMap();
+function getRoadmapStore(ctx) {
+  const taskStoreWithRoadmaps = ctx.taskStore;
+  if (typeof taskStoreWithRoadmaps.getRoadmapStore === "function") {
+    return taskStoreWithRoadmaps.getRoadmapStore();
+  }
+  const key = ctx.taskStore;
+  const cached = roadmapStoreCache.get(key);
+  if (cached)
+    return cached;
+  const store = new RoadmapStore(ctx.taskStore.getDatabase());
+  roadmapStoreCache.set(key, store);
+  return store;
+}
+function asRequest(req) {
+  return req;
+}
+function badRequest(message) {
+  return { status: 400, body: { error: message } };
+}
+function notFound(message) {
+  return { status: 404, body: { error: message } };
+}
+function serverError(message) {
+  return { status: 500, body: { error: message } };
+}
+function noContent() {
+  return { status: 204 };
+}
+function routeHandler(handler) {
+  return async (req, ctx) => {
+    const roadmapStore = getRoadmapStore(ctx);
+    try {
+      return await handler(asRequest(req), ctx, roadmapStore);
+    } catch (error) {
+      if (error instanceof Error && error.message.toLowerCase().includes("not found")) {
+        return notFound(error.message);
+      }
+      return serverError(error instanceof Error ? error.message : "Internal server error");
+    }
+  };
+}
+function validateTitle(title) {
+  if (!title || typeof title !== "string" || !title.trim()) {
+    throw new Error("title is required");
+  }
+  if (title.length > 200) {
+    throw new Error("title must not exceed 200 characters");
+  }
+  return title.trim();
+}
+function validateDescription(desc) {
+  if (desc === void 0 || desc === null)
+    return void 0;
+  if (typeof desc !== "string") {
+    throw new Error("description must be a string");
+  }
+  if (desc.length > 5e3) {
+    throw new Error("description must not exceed 5000 characters");
+  }
+  return desc.trim() || void 0;
+}
+function validateStringArray(arr, fieldName) {
+  if (!Array.isArray(arr)) {
+    throw new Error(`${fieldName} must be an array`);
+  }
+  if (!arr.every((item) => typeof item === "string")) {
+    throw new Error(`${fieldName} must be an array of strings`);
+  }
+  return arr;
+}
+function createRoadmapPluginRoutes() {
+  return [
+    {
+      method: "GET",
+      path: "/roadmaps",
+      handler: routeHandler((_req, _ctx, roadmapStore) => roadmapStore.listRoadmaps())
+    },
+    {
+      method: "POST",
+      path: "/roadmaps",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        const body = req.body;
+        try {
+          return {
+            status: 201,
+            body: roadmapStore.createRoadmap({
+              title: validateTitle(body?.title),
+              description: validateDescription(body?.description)
+            })
+          };
+        } catch (error) {
+          return badRequest(error instanceof Error ? error.message : "Invalid input");
+        }
+      })
+    },
+    {
+      method: "GET",
+      path: "/roadmaps/:roadmapId",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        const roadmap = roadmapStore.getRoadmapWithHierarchy(req.params.roadmapId);
+        return roadmap ? roadmap : notFound(`Roadmap ${req.params.roadmapId} not found`);
+      })
+    },
+    {
+      method: "PATCH",
+      path: "/roadmaps/:roadmapId",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        const body = req.body;
+        try {
+          return roadmapStore.updateRoadmap(req.params.roadmapId, {
+            title: body.title !== void 0 ? validateTitle(body.title) : void 0,
+            description: body.description !== void 0 ? validateDescription(body.description) : void 0
+          });
+        } catch (error) {
+          return badRequest(error instanceof Error ? error.message : "Invalid input");
+        }
+      })
+    },
+    { method: "DELETE", path: "/roadmaps/:roadmapId", handler: routeHandler((req, _ctx, roadmapStore) => {
+      roadmapStore.deleteRoadmap(req.params.roadmapId);
+      return noContent();
+    }) },
+    {
+      method: "POST",
+      path: "/roadmaps/:roadmapId/milestones",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        const body = req.body;
+        try {
+          return {
+            status: 201,
+            body: roadmapStore.createMilestone(req.params.roadmapId, {
+              title: validateTitle(body?.title),
+              description: validateDescription(body?.description)
+            })
+          };
+        } catch (error) {
+          return badRequest(error instanceof Error ? error.message : "Invalid input");
+        }
+      })
+    },
+    {
+      method: "POST",
+      path: "/roadmaps/:roadmapId/milestones/reorder",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        try {
+          const body = req.body;
+          roadmapStore.reorderMilestones({ roadmapId: req.params.roadmapId, orderedMilestoneIds: validateStringArray(body?.orderedMilestoneIds, "orderedMilestoneIds") });
+          return noContent();
+        } catch (error) {
+          return badRequest(error instanceof Error ? error.message : "Invalid input");
+        }
+      })
+    },
+    {
+      method: "PATCH",
+      path: "/roadmaps/milestones/:milestoneId",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        const body = req.body;
+        try {
+          return roadmapStore.updateMilestone(req.params.milestoneId, {
+            title: body.title !== void 0 ? validateTitle(body.title) : void 0,
+            description: body.description !== void 0 ? validateDescription(body.description) : void 0
+          });
+        } catch (error) {
+          return badRequest(error instanceof Error ? error.message : "Invalid input");
+        }
+      })
+    },
+    { method: "DELETE", path: "/roadmaps/milestones/:milestoneId", handler: routeHandler((req, _ctx, roadmapStore) => {
+      roadmapStore.deleteMilestone(req.params.milestoneId);
+      return noContent();
+    }) },
+    {
+      method: "POST",
+      path: "/roadmaps/milestones/:milestoneId/features",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        const body = req.body;
+        try {
+          return {
+            status: 201,
+            body: roadmapStore.createFeature(req.params.milestoneId, {
+              title: validateTitle(body?.title),
+              description: validateDescription(body?.description)
+            })
+          };
+        } catch (error) {
+          return badRequest(error instanceof Error ? error.message : "Invalid input");
+        }
+      })
+    },
+    {
+      method: "POST",
+      path: "/roadmaps/milestones/:milestoneId/features/reorder",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        try {
+          const body = req.body;
+          const milestone = roadmapStore.getMilestone(req.params.milestoneId);
+          if (!milestone)
+            return notFound(`Milestone ${req.params.milestoneId} not found`);
+          roadmapStore.reorderFeatures({ roadmapId: milestone.roadmapId, milestoneId: req.params.milestoneId, orderedFeatureIds: validateStringArray(body?.orderedFeatureIds, "orderedFeatureIds") });
+          return noContent();
+        } catch (error) {
+          return badRequest(error instanceof Error ? error.message : "Invalid input");
+        }
+      })
+    },
+    {
+      method: "PATCH",
+      path: "/roadmaps/features/:featureId",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        const body = req.body;
+        try {
+          return roadmapStore.updateFeature(req.params.featureId, {
+            title: body.title !== void 0 ? validateTitle(body.title) : void 0,
+            description: body.description !== void 0 ? validateDescription(body.description) : void 0
+          });
+        } catch (error) {
+          return badRequest(error instanceof Error ? error.message : "Invalid input");
+        }
+      })
+    },
+    { method: "DELETE", path: "/roadmaps/features/:featureId", handler: routeHandler((req, _ctx, roadmapStore) => {
+      roadmapStore.deleteFeature(req.params.featureId);
+      return noContent();
+    }) },
+    {
+      method: "POST",
+      path: "/roadmaps/features/:featureId/move",
+      handler: routeHandler((req, _ctx, roadmapStore) => {
+        const body = req.body;
+        if (!body?.targetMilestoneId)
+          return badRequest("targetMilestoneId is required");
+        if (typeof body.targetIndex !== "number")
+          return badRequest("targetIndex must be a number");
+        const feature = roadmapStore.getFeature(req.params.featureId);
+        if (!feature)
+          return notFound(`Feature ${req.params.featureId} not found`);
+        const fromMilestone = roadmapStore.getMilestone(feature.milestoneId);
+        if (!fromMilestone)
+          return notFound(`Source milestone ${feature.milestoneId} not found`);
+        const toMilestone = roadmapStore.getMilestone(body.targetMilestoneId);
+        if (!toMilestone)
+          return notFound(`Target milestone ${body.targetMilestoneId} not found`);
+        roadmapStore.moveFeature({
+          roadmapId: fromMilestone.roadmapId,
+          featureId: req.params.featureId,
+          fromMilestoneId: feature.milestoneId,
+          toMilestoneId: body.targetMilestoneId,
+          targetOrderIndex: body.targetIndex
+        });
+        return noContent();
+      })
+    },
+    {
+      method: "POST",
+      path: "/roadmaps/:roadmapId/suggestions/milestones",
+      handler: routeHandler(async (req, ctx, roadmapStore) => {
+        const roadmap = roadmapStore.getRoadmap(req.params.roadmapId);
+        if (!roadmap)
+          return notFound(`Roadmap ${req.params.roadmapId} not found`);
+        try {
+          validateSuggestionInput(req.body);
+        } catch (error) {
+          if (error instanceof ValidationError)
+            return badRequest(error.message);
+          throw error;
+        }
+        try {
+          const body = req.body;
+          const suggestions = await generateMilestoneSuggestions(body.goalPrompt, body.count, ctx.taskStore.getRootDir(), void 0, void 0, ctx.createAiSession);
+          return { suggestions };
+        } catch (error) {
+          if (error instanceof ParseError)
+            return serverError(error.message);
+          if (error instanceof ServiceUnavailableError) {
+            return { status: 503, body: { error: error.message } };
+          }
+          throw error;
+        }
+      })
+    },
+    {
+      method: "POST",
+      path: "/roadmaps/milestones/:milestoneId/suggestions/features",
+      handler: routeHandler(async (req, ctx, roadmapStore) => {
+        const milestone = roadmapStore.getMilestone(req.params.milestoneId);
+        if (!milestone)
+          return notFound(`Milestone ${req.params.milestoneId} not found`);
+        const roadmap = roadmapStore.getRoadmap(milestone.roadmapId);
+        if (!roadmap)
+          return notFound(`Roadmap ${milestone.roadmapId} not found`);
+        try {
+          validateFeatureSuggestionInput(req.body);
+        } catch (error) {
+          if (error instanceof ValidationError)
+            return badRequest(error.message);
+          throw error;
+        }
+        try {
+          const body = req.body;
+          const suggestions = await generateFeatureSuggestions({
+            roadmapTitle: roadmap.title,
+            roadmapDescription: roadmap.description,
+            milestoneTitle: milestone.title,
+            milestoneDescription: milestone.description,
+            existingFeatureTitles: roadmapStore.listFeatures(milestone.id).map((feature) => feature.title)
+          }, body.count, body.prompt, ctx.taskStore.getRootDir(), void 0, void 0, ctx.createAiSession);
+          return { suggestions };
+        } catch (error) {
+          if (error instanceof ParseError)
+            return serverError(error.message);
+          if (error instanceof ServiceUnavailableError) {
+            return { status: 503, body: { error: error.message } };
+          }
+          throw error;
+        }
+      })
+    },
+    {
+      method: "GET",
+      path: "/roadmaps/:roadmapId/export",
+      handler: routeHandler((req, _ctx, roadmapStore) => roadmapStore.getRoadmapExport(req.params.roadmapId))
+    },
+    {
+      method: "GET",
+      path: "/roadmaps/:roadmapId/handoff",
+      handler: routeHandler((req, _ctx, roadmapStore) => ({
+        mission: roadmapStore.getMissionPlanningHandoff(req.params.roadmapId),
+        features: roadmapStore.listFeatureTaskPlanningHandoffs(req.params.roadmapId)
+      }))
+    },
+    {
+      method: "GET",
+      path: "/roadmaps/:roadmapId/handoff/mission",
+      handler: routeHandler((req, _ctx, roadmapStore) => roadmapStore.getMissionPlanningHandoff(req.params.roadmapId))
+    },
+    {
+      method: "GET",
+      path: "/roadmaps/:roadmapId/milestones/:milestoneId/features/:featureId/handoff/task",
+      handler: routeHandler((req, _ctx, roadmapStore) => roadmapStore.getRoadmapFeatureHandoff(req.params.roadmapId, req.params.milestoneId, req.params.featureId))
+    }
+  ];
+}
+
+// ../../plugins/fusion-plugin-roadmap/src/roadmap-schema.ts
+function ensureRoadmapSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS roadmaps (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      createdAt TEXT NOT NULL,
+      updatedAt TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS roadmap_milestones (
+      id TEXT PRIMARY KEY,
+      roadmapId TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      orderIndex INTEGER NOT NULL,
+      createdAt TEXT NOT NULL,
+      updatedAt TEXT NOT NULL,
+      FOREIGN KEY (roadmapId) REFERENCES roadmaps(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS roadmap_features (
+      id TEXT PRIMARY KEY,
+      milestoneId TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      orderIndex INTEGER NOT NULL,
+      createdAt TEXT NOT NULL,
+      updatedAt TEXT NOT NULL,
+      FOREIGN KEY (milestoneId) REFERENCES roadmap_milestones(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idxRoadmapMilestonesRoadmapOrder
+      ON roadmap_milestones(roadmapId, orderIndex, createdAt, id);
+
+    CREATE INDEX IF NOT EXISTS idxRoadmapFeaturesMilestoneOrder
+      ON roadmap_features(milestoneId, orderIndex, createdAt, id);
+  `);
+}
+
+// ../../plugins/fusion-plugin-roadmap/src/store/roadmap-handoff.ts
+function buildFeatureSourceRef(roadmap, milestone, feature) {
+  return {
+    roadmapId: roadmap.id,
+    milestoneId: milestone.id,
+    featureId: feature.id,
+    roadmapTitle: roadmap.title,
+    milestoneTitle: milestone.title,
+    milestoneOrderIndex: milestone.orderIndex,
+    featureOrderIndex: feature.orderIndex
+  };
+}
+function mapFeatureToTaskHandoff(roadmap, milestone, feature) {
+  return {
+    source: buildFeatureSourceRef(roadmap, milestone, feature),
+    title: feature.title,
+    description: feature.description
+  };
+}
+function mapRoadmapToMissionHandoff(roadmap, milestones, featuresByMilestoneId) {
+  const normalizedMilestones = normalizeRoadmapMilestoneOrder(milestones);
+  const milestoneHandoffs = normalizedMilestones.map((milestone) => {
+    const rawFeatures = featuresByMilestoneId.get(milestone.id) ?? [];
+    const normalizedFeatures = normalizeRoadmapFeatureOrder(rawFeatures);
+    return {
+      sourceMilestoneId: milestone.id,
+      title: milestone.title,
+      description: milestone.description,
+      orderIndex: milestone.orderIndex,
+      features: normalizedFeatures.map((feature) => ({
+        sourceFeatureId: feature.id,
+        title: feature.title,
+        description: feature.description,
+        orderIndex: feature.orderIndex
+      }))
+    };
+  });
+  return {
+    sourceRoadmapId: roadmap.id,
+    title: roadmap.title,
+    description: roadmap.description,
+    milestones: milestoneHandoffs
+  };
+}
+function mapRoadmapWithHierarchyToMissionHandoff(roadmapWithHierarchy) {
+  const featuresByMilestoneId = /* @__PURE__ */ new Map();
+  for (const milestone of roadmapWithHierarchy.milestones) {
+    featuresByMilestoneId.set(milestone.id, milestone.features);
+  }
+  return mapRoadmapToMissionHandoff(
+    roadmapWithHierarchy,
+    roadmapWithHierarchy.milestones,
+    featuresByMilestoneId
+  );
+}
+function mapAllFeaturesToTaskHandoffs(roadmap, milestones, featuresByMilestoneId) {
+  const normalizedMilestones = normalizeRoadmapMilestoneOrder(milestones);
+  const handoffs = [];
+  for (const milestone of normalizedMilestones) {
+    const rawFeatures = featuresByMilestoneId.get(milestone.id) ?? [];
+    const normalizedFeatures = normalizeRoadmapFeatureOrder(rawFeatures);
+    for (const feature of normalizedFeatures) {
+      handoffs.push(mapFeatureToTaskHandoff(roadmap, milestone, feature));
+    }
+  }
+  return handoffs;
+}
+
+// ../../plugins/fusion-plugin-roadmap/src/index.ts
+var plugin = definePlugin({
+  manifest: {
+    id: "fusion-plugin-roadmap",
+    name: "Roadmaps",
+    version: "0.1.0",
+    description: "Standalone roadmap planning plugin"
+  },
+  state: "installed",
+  hooks: {
+    onSchemaInit: ensureRoadmapSchema
+  },
+  routes: createRoadmapPluginRoutes(),
+  dashboardViews: [
+    {
+      viewId: "roadmaps",
+      label: "Roadmaps",
+      componentPath: "./dashboard-view",
+      icon: "Map",
+      placement: "primary",
+      order: 30
+    }
+  ]
+});
+var index_default = plugin;
+export {
+  RoadmapStore,
+  applyRoadmapFeatureReorder,
+  applyRoadmapMilestoneReorder,
+  createRoadmapPluginRoutes,
+  index_default as default,
+  ensureRoadmapSchema,
+  mapAllFeaturesToTaskHandoffs,
+  mapFeatureToTaskHandoff,
+  mapRoadmapToMissionHandoff,
+  mapRoadmapWithHierarchyToMissionHandoff,
+  moveRoadmapFeature,
+  normalizeRoadmapFeatureOrder,
+  normalizeRoadmapMilestoneOrder
+};