@runfusion/fusion 0.38.1 → 0.40.1

package/dist/plugins/fusion-plugin-compound-engineering/bundled.js

@@ -0,0 +1,1984 @@
+// ../plugin-sdk/src/index.ts
+import {
+  WORKFLOW_EXTENSION_SCHEMA_VERSION,
+  workflowExtensionRegistryId,
+  createBoardActionServices
+} from "@fusion/core";
+function definePlugin(plugin2) {
+  return plugin2;
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/skills.ts
+var COMPOUND_ENGINEERING_SKILLS = [
+  {
+    skillId: "ce-strategy",
+    name: "ce-strategy",
+    description: "Create or maintain STRATEGY.md \u2014 the product's target problem, approach, users, key metrics, and tracks of work.",
+    skillFiles: ["skills/ce-strategy/SKILL.md"],
+    enabled: true,
+    triggerPatterns: ["strategy", "roadmap", "what are we working on", "set up the strategy doc"]
+  },
+  {
+    skillId: "ce-ideate",
+    name: "ce-ideate",
+    description: "Generate and critically evaluate grounded ideas about a topic before committing to one direction.",
+    skillFiles: ["skills/ce-ideate/SKILL.md"],
+    enabled: true,
+    triggerPatterns: ["ideate", "give me ideas", "what should I improve", "surprise me"]
+  },
+  {
+    skillId: "ce-brainstorm",
+    name: "ce-brainstorm",
+    description: "Explore requirements and approaches through collaborative dialogue, then write a right-sized requirements document.",
+    skillFiles: ["skills/ce-brainstorm/SKILL.md"],
+    enabled: true,
+    triggerPatterns: ["brainstorm", "what should we build", "help me think through"]
+  },
+  {
+    skillId: "ce-plan",
+    name: "ce-plan",
+    description: "Create structured plans for multi-step tasks and optionally deepen existing plans via sub-agent review.",
+    skillFiles: ["skills/ce-plan/SKILL.md"],
+    enabled: true,
+    triggerPatterns: ["plan this", "create a plan", "break this down", "deepen the plan"]
+  },
+  {
+    skillId: "ce-work",
+    name: "ce-work",
+    description: "Execute work efficiently while maintaining quality and finishing features.",
+    skillFiles: ["skills/ce-work/SKILL.md"],
+    enabled: true,
+    triggerPatterns: ["do the work", "implement", "execute the plan", "finish this feature"]
+  },
+  {
+    skillId: "ce-code-review",
+    name: "ce-code-review",
+    description: "Structured code review using tiered persona agents, confidence-gated findings, and a merge/dedup pipeline.",
+    skillFiles: ["skills/ce-code-review/SKILL.md"],
+    enabled: true,
+    triggerPatterns: ["code review", "review this change", "review before PR"]
+  },
+  {
+    skillId: "ce-compound",
+    name: "ce-compound",
+    description: "Document a recently solved problem to compound the team's knowledge or the project's shared CONCEPTS.md vocabulary.",
+    skillFiles: ["skills/ce-compound/SKILL.md"],
+    enabled: true,
+    triggerPatterns: ["compound this", "document this learning", "capture this solution"]
+  }
+];
+
+// ../../plugins/fusion-plugin-compound-engineering/src/skill-installation.ts
+import { cpSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBundledSkillsRoot() {
+  const here = fileURLToPath(import.meta.url);
+  const dir = dirname(here);
+  const local = resolve(dir, "skills");
+  if (existsSync(local)) return local;
+  return resolve(dir, "..", "src", "skills");
+}
+function resolveDefaultInstallTargetRoot() {
+  const here = fileURLToPath(import.meta.url);
+  return resolve(dirname(here), "..", ".fusion-ce-skills");
+}
+var GLOBAL_SKILL_DIR_PATTERN = /[\\/]\.(claude|codex|gemini)[\\/]skills([\\/]|$)/;
+function assertPluginLocalTarget(targetRoot) {
+  const normalized = resolve(targetRoot);
+  if (GLOBAL_SKILL_DIR_PATTERN.test(normalized + sep)) {
+    throw new Error(
+      `Refusing to install Compound Engineering skills into a global client skills directory: ${normalized}. Install target MUST be plugin-local (never <home>/.claude|.codex|.gemini/skills).`
+    );
+  }
+}
+function assertValidSkillSource(skillId, sourceDir) {
+  if (!existsSync(sourceDir)) {
+    throw new Error(`Bundled skill source directory missing for '${skillId}': ${sourceDir}`);
+  }
+  const skillMd = join(sourceDir, "SKILL.md");
+  if (!existsSync(skillMd)) {
+    throw new Error(`Bundled skill '${skillId}' has no SKILL.md at ${skillMd}`);
+  }
+  const content = readFileSync(skillMd, "utf-8");
+  if (!/^---[\s\S]*?\bname\s*:\s*\S/m.test(content)) {
+    throw new Error(
+      `Bundled skill '${skillId}' SKILL.md at ${skillMd} is missing a frontmatter 'name:' field`
+    );
+  }
+}
+function installBundledCeSkills(options = {}) {
+  const targetRoot = options.targetRoot ? resolve(options.targetRoot) : resolveDefaultInstallTargetRoot();
+  assertPluginLocalTarget(targetRoot);
+  const sourceRoot = options.sourceRoot ? resolve(options.sourceRoot) : resolveBundledSkillsRoot();
+  const results = COMPOUND_ENGINEERING_SKILLS.map((skill) => {
+    const sourceDir = join(sourceRoot, skill.skillId);
+    const targetDir = join(targetRoot, skill.skillId);
+    try {
+      assertValidSkillSource(skill.skillId, sourceDir);
+      if (existsSync(targetDir)) {
+        return { skillId: skill.skillId, sourceDir, targetDir, outcome: "skipped", reason: "existing install preserved" };
+      }
+      mkdirSync(targetRoot, { recursive: true });
+      cpSync(sourceDir, targetDir, { recursive: true });
+      return { skillId: skill.skillId, sourceDir, targetDir, outcome: "installed" };
+    } catch (error) {
+      return {
+        skillId: skill.skillId,
+        sourceDir,
+        targetDir,
+        outcome: "error",
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  return { targetRoot, results };
+}
+function isPluginLocalPath(p) {
+  return isAbsolute(p) && !GLOBAL_SKILL_DIR_PATTERN.test(resolve(p) + sep);
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/schema.ts
+function ensureCeSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ce_sessions (
+      id TEXT PRIMARY KEY,
+      stage TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN (
+        'launching','active','awaiting_input','completed','error','interrupted'
+      )),
+      currentQuestion TEXT,
+      conversationHistory TEXT NOT NULL DEFAULT '[]',
+      projectId TEXT,
+      artifactPath TEXT,
+      error TEXT,
+      turnIntervalMs INTEGER NOT NULL DEFAULT 120000,
+      lastActivityAt INTEGER NOT NULL,
+      createdAt TEXT NOT NULL,
+      updatedAt TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idxCeSessionsStatusUpdated
+      ON ce_sessions(status, updatedAt DESC, id);
+
+    CREATE INDEX IF NOT EXISTS idxCeSessionsStageCreated
+      ON ce_sessions(stage, createdAt DESC, id);
+
+    CREATE INDEX IF NOT EXISTS idxCeSessionsProject
+      ON ce_sessions(projectId, updatedAt DESC, id);
+
+    CREATE TABLE IF NOT EXISTS ce_pipeline_links (
+      id TEXT PRIMARY KEY,
+      taskId TEXT NOT NULL,
+      cePipelineId TEXT NOT NULL,
+      ceStageId TEXT NOT NULL,
+      ceArtifactPath TEXT,
+      createdAt TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idxCePipelineLinksPipeline
+      ON ce_pipeline_links(cePipelineId, createdAt DESC, id);
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idxCePipelineLinksTask
+      ON ce_pipeline_links(taskId);
+
+    CREATE TABLE IF NOT EXISTS ce_pipeline_state (
+      cePipelineId TEXT PRIMARY KEY,
+      currentStage TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN (
+        'running','advancing','awaiting_board','completed'
+      )),
+      lastArtifactPath TEXT,
+      createdAt TEXT NOT NULL,
+      updatedAt TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idxCePipelineStateStatus
+      ON ce_pipeline_state(status, updatedAt DESC, cePipelineId);
+
+    CREATE TABLE IF NOT EXISTS ce_pipeline_sync_queue (
+      id TEXT PRIMARY KEY,
+      cePipelineId TEXT NOT NULL,
+      taskId TEXT NOT NULL,
+      reason TEXT NOT NULL,
+      fromColumn TEXT,
+      toColumn TEXT,
+      enqueuedAt TEXT NOT NULL,
+      processedAt TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idxCePipelineSyncQueuePending
+      ON ce_pipeline_sync_queue(processedAt, enqueuedAt, id);
+
+    CREATE INDEX IF NOT EXISTS idxCePipelineSyncQueuePipeline
+      ON ce_pipeline_sync_queue(cePipelineId, enqueuedAt, id);
+  `);
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/session/orchestrator.ts
+import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2 } from "node:path";
+
+// ../../plugins/fusion-plugin-compound-engineering/src/sync/pipeline-store.ts
+import { randomUUID } from "node:crypto";
+function rowToState(row) {
+  return {
+    cePipelineId: row.cePipelineId,
+    currentStage: row.currentStage,
+    status: row.status,
+    lastArtifactPath: row.lastArtifactPath,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function rowToQueueEntry(row) {
+  return {
+    id: row.id,
+    cePipelineId: row.cePipelineId,
+    taskId: row.taskId,
+    reason: row.reason,
+    fromColumn: row.fromColumn,
+    toColumn: row.toColumn,
+    enqueuedAt: row.enqueuedAt,
+    processedAt: row.processedAt
+  };
+}
+function rowToLink(row) {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    cePipelineId: row.cePipelineId,
+    ceStageId: row.ceStageId,
+    ceArtifactPath: row.ceArtifactPath,
+    createdAt: row.createdAt
+  };
+}
+var CePipelineStore = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureCeSchema(db);
+  }
+  /** Record a task→pipeline/artifact link. */
+  createLink(input) {
+    const link = {
+      id: input.id ?? randomUUID(),
+      taskId: input.taskId,
+      cePipelineId: input.cePipelineId,
+      ceStageId: input.ceStageId,
+      ceArtifactPath: input.ceArtifactPath ?? null,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.db.prepare(
+      `INSERT INTO ce_pipeline_links
+          (id, taskId, cePipelineId, ceStageId, ceArtifactPath, createdAt)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(link.id, link.taskId, link.cePipelineId, link.ceStageId, link.ceArtifactPath, link.createdAt);
+    return link;
+  }
+  /** All links produced by a given CE pipeline, newest first. */
+  listByPipeline(cePipelineId) {
+    const rows = this.db.prepare(`SELECT * FROM ce_pipeline_links WHERE cePipelineId = ? ORDER BY createdAt DESC, id`).all(cePipelineId);
+    return rows.map(rowToLink);
+  }
+  /** Resolve a board task back to its CE link (the back-reference). */
+  findByTaskId(taskId) {
+    const row = this.db.prepare(`SELECT * FROM ce_pipeline_links WHERE taskId = ?`).get(taskId);
+    return row ? rowToLink(row) : void 0;
+  }
+  // ── CE-pipeline STATE machine (U8) ───────────────────────────────────
+  // Separate from board-task columns: this table is the pipeline's OWN state.
+  /** Read a pipeline's own state record. */
+  getState(cePipelineId) {
+    const row = this.db.prepare(`SELECT * FROM ce_pipeline_state WHERE cePipelineId = ?`).get(cePipelineId);
+    return row ? rowToState(row) : void 0;
+  }
+  /** All pipeline state records (the reconciler sweeps every one). */
+  listAllState() {
+    const rows = this.db.prepare(`SELECT * FROM ce_pipeline_state ORDER BY updatedAt DESC, cePipelineId`).all();
+    return rows.map(rowToState);
+  }
+  /**
+   * Create or update a pipeline's state. Idempotent on `cePipelineId`. `status`
+   * defaults to `running` on first write and is preserved on update unless given.
+   */
+  upsertState(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.getState(input.cePipelineId);
+    const status = input.status ?? existing?.status ?? "running";
+    const lastArtifactPath = input.lastArtifactPath !== void 0 ? input.lastArtifactPath : existing?.lastArtifactPath ?? null;
+    if (existing) {
+      this.db.prepare(
+        `UPDATE ce_pipeline_state
+             SET currentStage = ?, status = ?, lastArtifactPath = ?, updatedAt = ?
+           WHERE cePipelineId = ?`
+      ).run(input.currentStage, status, lastArtifactPath, now, input.cePipelineId);
+    } else {
+      this.db.prepare(
+        `INSERT INTO ce_pipeline_state
+             (cePipelineId, currentStage, status, lastArtifactPath, createdAt, updatedAt)
+           VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(input.cePipelineId, input.currentStage, status, lastArtifactPath, now, now);
+    }
+    return this.getState(input.cePipelineId);
+  }
+  /**
+   * Transition a pipeline to a new stage/status. Returns the updated state, or
+   * `undefined` if the pipeline has no state row yet (caller should seed first).
+   */
+  transitionState(cePipelineId, next) {
+    const existing = this.getState(cePipelineId);
+    if (!existing) return void 0;
+    return this.upsertState({
+      cePipelineId,
+      currentStage: next.currentStage ?? existing.currentStage,
+      status: next.status ?? existing.status,
+      lastArtifactPath: next.lastArtifactPath !== void 0 ? next.lastArtifactPath : existing.lastArtifactPath
+    });
+  }
+  // ── Event-enqueue seam (U8 / FN-5719) ────────────────────────────────
+  // Hooks write here FAST and return; the reconciler drains. A missed enqueue is
+  // still recovered because reconcile() re-derives from board state too.
+  /** Append a pending board→pipeline sync signal. Fast, append-only. */
+  enqueueSync(input) {
+    const entry = {
+      id: input.id ?? randomUUID(),
+      cePipelineId: input.cePipelineId,
+      taskId: input.taskId,
+      reason: input.reason,
+      fromColumn: input.fromColumn ?? null,
+      toColumn: input.toColumn ?? null,
+      enqueuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      processedAt: null
+    };
+    this.db.prepare(
+      `INSERT INTO ce_pipeline_sync_queue
+           (id, cePipelineId, taskId, reason, fromColumn, toColumn, enqueuedAt, processedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?, NULL)`
+    ).run(entry.id, entry.cePipelineId, entry.taskId, entry.reason, entry.fromColumn, entry.toColumn, entry.enqueuedAt);
+    return entry;
+  }
+  /** All pending (un-drained) queue entries, oldest first. */
+  listPendingSync() {
+    const rows = this.db.prepare(`SELECT * FROM ce_pipeline_sync_queue WHERE processedAt IS NULL ORDER BY enqueuedAt, id`).all();
+    return rows.map(rowToQueueEntry);
+  }
+  /** Mark a queue entry drained (idempotent). */
+  markSyncProcessed(id) {
+    this.db.prepare(`UPDATE ce_pipeline_sync_queue SET processedAt = ? WHERE id = ? AND processedAt IS NULL`).run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+};
+var storeCache = /* @__PURE__ */ new WeakMap();
+function getCePipelineStore(ctx) {
+  const key = ctx.taskStore;
+  const cached = storeCache.get(key);
+  if (cached) return cached;
+  const store = new CePipelineStore(ctx.taskStore.getDatabase());
+  storeCache.set(key, store);
+  return store;
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/sync/ce-task.ts
+var CE_PLUGIN_ID = "fusion-plugin-compound-engineering";
+var CE_WORK_SOURCE_TYPE = "workflow_step";
+async function createCeTaskWithLink(taskStore, pipelineStore, spec) {
+  const task = await taskStore.createTask({
+    title: spec.title,
+    description: spec.description,
+    column: spec.column,
+    source: {
+      sourceType: CE_WORK_SOURCE_TYPE,
+      sourceSessionId: spec.cePipelineId,
+      sourceMetadata: {
+        pluginId: CE_PLUGIN_ID,
+        cePipelineId: spec.cePipelineId,
+        ceStageId: spec.ceStageId,
+        ceArtifactPath: spec.ceArtifactPath
+      }
+    }
+  });
+  pipelineStore.createLink({
+    taskId: task.id,
+    cePipelineId: spec.cePipelineId,
+    ceStageId: spec.ceStageId,
+    ceArtifactPath: spec.ceArtifactPath
+  });
+  return task;
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/session/stage-registry.ts
+var STAGE_DEFINITIONS = [
+  {
+    stageId: "strategy",
+    order: 100,
+    skillId: "ce-strategy",
+    artifactLocation: "STRATEGY.md",
+    icon: "Compass",
+    label: "Strategy",
+    artifactGlob: "STRATEGY.md"
+  },
+  {
+    stageId: "ideate",
+    order: 200,
+    skillId: "ce-ideate",
+    artifactLocation: "docs/ideation/",
+    icon: "Lightbulb",
+    label: "Ideate",
+    artifactGlob: "docs/ideation/**/*.md"
+  },
+  {
+    stageId: "brainstorm",
+    order: 300,
+    skillId: "ce-brainstorm",
+    artifactLocation: "docs/brainstorms/",
+    icon: "Sparkles",
+    label: "Brainstorm",
+    artifactGlob: "docs/brainstorms/**/*.md"
+  },
+  {
+    stageId: "plan",
+    order: 400,
+    skillId: "ce-plan",
+    artifactLocation: "docs/plans/",
+    icon: "ListChecks",
+    label: "Plan",
+    artifactGlob: "docs/plans/**/*.md"
+  },
+  {
+    // The work stage (U7). Its `ce-work` skill drives execution and, on
+    // `complete`, carries a derived task list that the orchestrator lands on the
+    // board (tagged CE-originated + recorded as pipeline links). The artifact is
+    // the work log / summary for this stage.
+    stageId: "work",
+    order: 500,
+    skillId: "ce-work",
+    artifactLocation: "docs/work/",
+    icon: "Hammer",
+    label: "Work",
+    artifactGlob: "docs/work/**/*.md"
+  }
+];
+var REGISTRY = new Map(STAGE_DEFINITIONS.map((s) => [s.stageId, s]));
+function getStage(stageId) {
+  return REGISTRY.get(stageId);
+}
+function listStages() {
+  return [...REGISTRY.values()].sort((a, b) => a.order - b.order || a.stageId.localeCompare(b.stageId));
+}
+function registerStage(def) {
+  REGISTRY.set(def.stageId, def);
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/settings.ts
+var DEFAULT_PROVIDER = "";
+var DEFAULT_MODEL_ID = "";
+var DEFAULT_ENABLED_STAGES = listStages().map((s) => s.stageId);
+var DEFAULT_RECONCILE_ON_HOOKS = true;
+var DEFAULT_RECONCILE_INTERVAL_MINUTES = 15;
+var settingsSchema = {
+  defaultProvider: {
+    type: "string",
+    label: "Default Session Provider",
+    description: "Model provider used for CE interactive sessions (for example anthropic). Leave blank to use the host default.",
+    group: "Sessions",
+    defaultValue: DEFAULT_PROVIDER
+  },
+  defaultModelId: {
+    type: "string",
+    label: "Default Session Model",
+    description: "Model ID within the provider used for CE interactive sessions. Leave blank to use the host default.",
+    group: "Sessions",
+    defaultValue: DEFAULT_MODEL_ID
+  },
+  enabledStages: {
+    type: "array",
+    itemType: "string",
+    label: "Enabled Stages",
+    description: "Stage IDs that may be launched from the Compound Engineering view (for example strategy, ideate, brainstorm, plan, work).",
+    group: "Sessions",
+    defaultValue: DEFAULT_ENABLED_STAGES
+  },
+  reconcileOnHooks: {
+    type: "boolean",
+    label: "Reconcile on Board Changes",
+    description: "Run the board\u2192pipeline reconcile sweep automatically after task move/complete hooks. Disable to only reconcile on demand.",
+    group: "Sync",
+    defaultValue: DEFAULT_RECONCILE_ON_HOOKS
+  },
+  reconcileIntervalMinutes: {
+    type: "number",
+    label: "Reconcile Cadence (minutes)",
+    description: "Cadence hint for how often an on-demand refresh surface sweeps the reconciler. Not a continuous poll loop.",
+    group: "Sync",
+    defaultValue: DEFAULT_RECONCILE_INTERVAL_MINUTES
+  }
+};
+function asString(settings, key) {
+  const value = settings[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function asBoolean(settings, key, fallback) {
+  const value = settings[key];
+  return typeof value === "boolean" ? value : fallback;
+}
+function asNumber(settings, key, fallback) {
+  const value = settings[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function asStringArray(settings, key, fallback) {
+  const value = settings[key];
+  if (!Array.isArray(value)) return [...fallback];
+  const normalized = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+  return normalized.length > 0 ? normalized : [...fallback];
+}
+function getDefaultProvider(settings) {
+  return asString(settings, "defaultProvider");
+}
+function getDefaultModelId(settings) {
+  return asString(settings, "defaultModelId");
+}
+function getEnabledStages(settings) {
+  return asStringArray(settings, "enabledStages", listStages().map((s) => s.stageId));
+}
+function getReconcileOnHooks(settings) {
+  return asBoolean(settings, "reconcileOnHooks", DEFAULT_RECONCILE_ON_HOOKS);
+}
+function getReconcileIntervalMinutes(settings) {
+  return Math.max(1, Math.floor(asNumber(settings, "reconcileIntervalMinutes", DEFAULT_RECONCILE_INTERVAL_MINUTES)));
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/session/session-store.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var CE_SESSION_STATUSES = [
+  "launching",
+  "active",
+  "awaiting_input",
+  "completed",
+  "error",
+  "interrupted"
+];
+function asCeSessionStatus(value) {
+  return value && CE_SESSION_STATUSES.includes(value) ? value : void 0;
+}
+var STALE_INTERVAL_MULTIPLE = 3;
+var DEFAULT_TURN_INTERVAL_MS = 12e4;
+function safeParse(raw, fallback, isValid) {
+  if (!raw) return fallback;
+  try {
+    const parsed = JSON.parse(raw);
+    return isValid(parsed) ? parsed : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function isConversationHistory(value) {
+  return Array.isArray(value) && value.every((turn) => {
+    if (typeof turn !== "object" || turn === null) return false;
+    const t = turn;
+    return (t.role === "user" || t.role === "agent") && typeof t.text === "string" && typeof t.at === "string";
+  });
+}
+function isPlanningQuestionOrNull(value) {
+  if (value === null) return true;
+  if (typeof value !== "object") return false;
+  const q = value;
+  return typeof q.id === "string" && typeof q.type === "string" && typeof q.question === "string";
+}
+function rowToSession(row) {
+  return {
+    id: row.id,
+    stage: row.stage,
+    status: row.status,
+    currentQuestion: safeParse(row.currentQuestion, null, isPlanningQuestionOrNull),
+    conversationHistory: safeParse(row.conversationHistory, [], isConversationHistory),
+    projectId: row.projectId,
+    artifactPath: row.artifactPath,
+    error: row.error,
+    turnIntervalMs: row.turnIntervalMs,
+    lastActivityAt: row.lastActivityAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+var CeSessionStore = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureCeSchema(db);
+  }
+  create(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const session = {
+      id: input.id ?? randomUUID2(),
+      stage: input.stage,
+      status: "launching",
+      currentQuestion: null,
+      conversationHistory: [],
+      projectId: input.projectId ?? null,
+      artifactPath: input.artifactPath ?? null,
+      error: null,
+      turnIntervalMs: input.turnIntervalMs ?? DEFAULT_TURN_INTERVAL_MS,
+      lastActivityAt: Date.now(),
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.prepare(
+      `INSERT INTO ce_sessions
+          (id, stage, status, currentQuestion, conversationHistory, projectId, artifactPath, error, turnIntervalMs, lastActivityAt, createdAt, updatedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      session.id,
+      session.stage,
+      session.status,
+      null,
+      JSON.stringify(session.conversationHistory),
+      session.projectId,
+      session.artifactPath,
+      null,
+      session.turnIntervalMs,
+      session.lastActivityAt,
+      session.createdAt,
+      session.updatedAt
+    );
+    return session;
+  }
+  get(id) {
+    const row = this.db.prepare(`SELECT * FROM ce_sessions WHERE id = ?`).get(id);
+    return row ? rowToSession(row) : void 0;
+  }
+  list(filter = {}) {
+    const clauses = [];
+    const params = [];
+    if (filter.status) {
+      clauses.push("status = ?");
+      params.push(filter.status);
+    }
+    if (filter.stage) {
+      clauses.push("stage = ?");
+      params.push(filter.stage);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM ce_sessions ${where} ORDER BY updatedAt DESC, id`).all(...params);
+    return rows.map(rowToSession);
+  }
+  /**
+   * Patch a session. Always bumps `updatedAt`; bumps `lastActivityAt` unless the
+   * caller explicitly overrides it (used by liveness tests to simulate age).
+   */
+  update(id, patch) {
+    const existing = this.get(id);
+    if (!existing) return void 0;
+    const next = {
+      ...existing,
+      ...patch,
+      lastActivityAt: patch.lastActivityAt ?? Date.now(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.db.prepare(
+      `UPDATE ce_sessions SET
+           status = ?, currentQuestion = ?, conversationHistory = ?, projectId = ?,
+           artifactPath = ?, error = ?, lastActivityAt = ?, updatedAt = ?
+         WHERE id = ?`
+    ).run(
+      next.status,
+      next.currentQuestion ? JSON.stringify(next.currentQuestion) : null,
+      JSON.stringify(next.conversationHistory),
+      next.projectId,
+      next.artifactPath,
+      next.error,
+      next.lastActivityAt,
+      next.updatedAt,
+      id
+    );
+    return next;
+  }
+  /** Delete a session row. Returns true when a row was removed. */
+  delete(id) {
+    const result = this.db.prepare(`DELETE FROM ce_sessions WHERE id = ?`).run(id);
+    return Number(result.changes ?? 0) > 0;
+  }
+  /** Append a turn to the conversation history (no other field touched). */
+  appendHistory(id, turn) {
+    const existing = this.get(id);
+    if (!existing) return void 0;
+    return this.update(id, { conversationHistory: [...existing.conversationHistory, turn] });
+  }
+  /**
+   * Interval-relative staleness: a non-terminal session is stale only when its
+   * last activity is older than `multiple × turnIntervalMs`. A healthy-but-slow
+   * session (within the interval band) is NOT stale. Terminal sessions
+   * (completed/error/interrupted) are never "stale" — they are already settled.
+   */
+  isStale(session, now = Date.now(), multiple = STALE_INTERVAL_MULTIPLE) {
+    if (session.status === "completed" || session.status === "error" || session.status === "interrupted") {
+      return false;
+    }
+    return now - session.lastActivityAt > multiple * session.turnIntervalMs;
+  }
+  /**
+   * Recover sessions left non-terminal by a crash/restart. A session with a
+   * persisted `currentQuestion` is restored to `awaiting_input` (resumable);
+   * one without is marked `interrupted` with its progress preserved — never
+   * silently dropped. Returns the ids transitioned.
+   */
+  recoverStaleSessions(now = Date.now(), multiple = STALE_INTERVAL_MULTIPLE) {
+    const candidates = this.list().filter(
+      (s) => (s.status === "active" || s.status === "launching") && this.isStale(s, now, multiple)
+    );
+    const recovered = [];
+    for (const s of candidates) {
+      if (s.currentQuestion) {
+        this.update(s.id, { status: "awaiting_input" });
+      } else {
+        this.update(s.id, { status: "interrupted", error: s.error ?? "Session interrupted \u2014 progress preserved, resume to continue" });
+      }
+      recovered.push(s.id);
+    }
+    return recovered;
+  }
+};
+var storeCache2 = /* @__PURE__ */ new WeakMap();
+function getCeSessionStore(ctx) {
+  const key = ctx.taskStore;
+  const cached = storeCache2.get(key);
+  if (cached) return cached;
+  const store = new CeSessionStore(ctx.taskStore.getDatabase());
+  storeCache2.set(key, store);
+  return store;
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/session/orchestrator.ts
+var WORK_STAGE_ID = "work";
+var DEFAULT_TURN_TIMEOUT_MS = 12e4;
+var PROGRESS_EMIT_INTERVAL_MS = 500;
+var MAX_ACTIVITY_TURNS = 200;
+var MAX_ACTIVITY_TURN_CHARS = 16e3;
+var MAX_PERSISTED_ACTIVITY_TURNS = 50;
+var MAX_PERSISTED_ACTIVITY_TURN_CHARS = 4e3;
+var CE_EVENTS = {
+  turn: "compound-engineering:session-turn",
+  question: "compound-engineering:session-question",
+  completed: "compound-engineering:session-completed",
+  error: "compound-engineering:session-error",
+  interrupted: "compound-engineering:session-interrupted"
+};
+var CeTurnTimeoutError = class extends Error {
+  constructor(ms) {
+    super(`CE session turn stalled: no agent activity for ${ms}ms`);
+    this.name = "CeTurnTimeoutError";
+  }
+};
+function resolveStageSkillPaths() {
+  return [resolveDefaultInstallTargetRoot()];
+}
+function buildStageSystemPrompt(stage) {
+  return [
+    `You are running the Compound Engineering "${stage.stageId}" stage.`,
+    `Apply the bundled skill "${stage.skillId}" (it has been loaded into this session).`,
+    "",
+    "Drive the stage as an interactive question/answer flow. On every turn respond with ONLY a JSON object:",
+    '  - To ask the user something: {"type":"question","data":{"id":"<unique>","type":"single_select|multi_select|text|confirm","question":"...","options":[{"id":"..","label":".."}]}}',
+    '  - When the stage is finished: {"type":"complete","data":{"artifact":"<full markdown document>", ...}}',
+    "No markdown fences, no prose outside the JSON object.",
+    "",
+    `The user's reply arrives as {"type":"answer","questionId":"...","response":...}. The response takes one of three shapes:`,
+    "  - a direct answer to your question (an option id, array of option ids, text, or boolean),",
+    '  - {"value": <direct answer>, "comment": "<guidance>"} \u2014 apply the answer AND incorporate the guidance into how you proceed,',
+    '  - {"feedback": "<guidance only>"} \u2014 the user is steering rather than answering. Incorporate the feedback, adjust course, and either re-ask the question (possibly revised) or continue if the feedback resolves it.',
+    "Steering feedback is first-class input: never ignore it, and acknowledge course corrections in your next question or output."
+  ].join("\n");
+}
+var CeOrchestrator = class {
+  ctx;
+  store;
+  pipelineStore;
+  factory;
+  projectRoot;
+  turnTimeoutMs;
+  executor;
+  /** Live in-memory session handles keyed by ce_session id. */
+  live = /* @__PURE__ */ new Map();
+  /** Mid-turn working output per session (transient; flushed to history on settle). */
+  activity = /* @__PURE__ */ new Map();
+  /** Last progress timestamp per session (drives the inactivity watchdog). */
+  lastProgressAt = /* @__PURE__ */ new Map();
+  /** Last progress-driven emit per session (throttling). */
+  lastProgressEmitAt = /* @__PURE__ */ new Map();
+  /** Sessions currently REPLAYING history (rehydrate) — progress suppressed. */
+  replaying = /* @__PURE__ */ new Set();
+  constructor(deps) {
+    this.ctx = deps.ctx;
+    this.store = getCeSessionStore(deps.ctx);
+    this.pipelineStore = getCePipelineStore(deps.ctx);
+    this.factory = deps.createInteractiveAiSession ?? deps.ctx.createInteractiveAiSession;
+    this.projectRoot = deps.projectRoot ?? deps.ctx.taskStore.getRootDir();
+    this.turnTimeoutMs = deps.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS;
+    this.executor = deps.executor ?? { kind: "model" };
+  }
+  /**
+   * Resolve the session backend for a CE stage (U9 seam). Threaded from
+   * `OrchestratorDeps.executor`; defaults to the model-backed interactive
+   * session. Exposed so the seam contract is directly assertable in tests and so
+   * future stage-loop wiring has a single resolution point.
+   */
+  resolveExecutor() {
+    return this.executor;
+  }
+  /**
+   * Build the interactive-session options for a stage. The session runs with
+   * `cwd` on the real project root (where it reads context and writes the stage
+   * artifact) and is handed BOTH the stage's `ce-*` skill id and the plugin-local
+   * install directory to discover it from — so the live agent actually loads the
+   * bundled skill (closing the U2/U5 skill-discovery carry-forward). Model
+   * provider/model are setting-gated (U9); omitted keys let the host pick defaults.
+   */
+  buildSessionOptions(stage, sessionId) {
+    const defaultProvider = getDefaultProvider(this.ctx.settings);
+    const defaultModelId = getDefaultModelId(this.ctx.settings);
+    return {
+      cwd: this.projectRoot,
+      systemPrompt: buildStageSystemPrompt(stage),
+      tools: "coding",
+      requestedSkillNames: [stage.skillId],
+      additionalSkillPaths: resolveStageSkillPaths(),
+      onProgress: (event) => this.handleProgress(sessionId, event),
+      ...defaultProvider ? { defaultProvider } : {},
+      ...defaultModelId ? { defaultModelId } : {}
+    };
+  }
+  /**
+   * Live mid-turn visibility. Accumulates streamed deltas into the session's
+   * activity buffer (consecutive deltas of one kind merge into one turn; tool
+   * markers are discrete), pokes the inactivity watchdog, and — throttled —
+   * bumps the persisted liveness anchor and emits an observable turn event so
+   * push clients refetch. Replay (rehydrate) progress is fully suppressed:
+   * it reconstructs context, it is not new work.
+   */
+  handleProgress(sessionId, event) {
+    if (this.replaying.has(sessionId)) return;
+    this.lastProgressAt.set(sessionId, Date.now());
+    const turns = this.activity.get(sessionId) ?? [];
+    if (!this.activity.has(sessionId)) this.activity.set(sessionId, turns);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (event.type === "tool") {
+      if (event.phase === "start") {
+        turns.push({ kind: "tool", text: event.name, at: now, done: false });
+      } else {
+        for (let i = turns.length - 1; i >= 0; i--) {
+          const t = turns[i];
+          if (t.kind === "tool" && t.text === event.name && !t.done) {
+            t.done = true;
+            if (event.isError) t.isError = true;
+            break;
+          }
+        }
+      }
+    } else {
+      const last = turns[turns.length - 1];
+      if (last && last.kind === event.type) {
+        if (last.text.length < MAX_ACTIVITY_TURN_CHARS) {
+          last.text = (last.text + event.delta).slice(0, MAX_ACTIVITY_TURN_CHARS);
+        }
+      } else {
+        turns.push({ kind: event.type, text: event.delta.slice(0, MAX_ACTIVITY_TURN_CHARS), at: now });
+      }
+    }
+    if (turns.length > MAX_ACTIVITY_TURNS) turns.splice(0, turns.length - MAX_ACTIVITY_TURNS);
+    const nowMs = Date.now();
+    if (nowMs - (this.lastProgressEmitAt.get(sessionId) ?? 0) >= PROGRESS_EMIT_INTERVAL_MS) {
+      this.lastProgressEmitAt.set(sessionId, nowMs);
+      this.store.update(sessionId, {});
+      this.ctx.emitEvent(CE_EVENTS.turn, { sessionId, kind: "progress" });
+    }
+  }
+  /** Read the in-flight working output for a session (route accessor). */
+  getLiveActivity(sessionId) {
+    return this.activity.get(sessionId) ?? [];
+  }
+  /**
+   * Persist a condensed copy of the live activity buffer into history (so the
+   * transcript keeps the working trace after the turn settles), then clear it.
+   */
+  flushActivity(sessionId) {
+    const turns = this.activity.get(sessionId);
+    this.activity.delete(sessionId);
+    if (!turns || turns.length === 0) return;
+    const condensed = turns.slice(-MAX_PERSISTED_ACTIVITY_TURNS).map((t) => ({
+      ...t,
+      text: t.text.slice(0, MAX_PERSISTED_ACTIVITY_TURN_CHARS)
+    }));
+    this.store.appendHistory(sessionId, {
+      role: "agent",
+      text: JSON.stringify({ activity: { turns: condensed } }),
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Inactivity watchdog: rejects only after `turnTimeoutMs` with NO progress.
+   * Every progress event re-arms it, so a long actively-working turn survives;
+   * with a non-streaming factory it degrades to a fixed per-turn timeout.
+   */
+  createWatchdog(sessionId) {
+    let cancelled = false;
+    let timer;
+    this.lastProgressAt.set(sessionId, Date.now());
+    const promise = new Promise((_, reject) => {
+      const check = () => {
+        if (cancelled) return;
+        const elapsed = Date.now() - (this.lastProgressAt.get(sessionId) ?? 0);
+        if (elapsed >= this.turnTimeoutMs) {
+          reject(new CeTurnTimeoutError(this.turnTimeoutMs));
+          return;
+        }
+        timer = globalThis.setTimeout(check, this.turnTimeoutMs - elapsed);
+        timer.unref?.();
+      };
+      check();
+    });
+    return {
+      promise,
+      cancel: () => {
+        cancelled = true;
+        if (timer) clearTimeout(timer);
+      }
+    };
+  }
+  /**
+   * Start a fresh session for a registered stage and run the opening turn.
+   *
+   * `detach: true` (the route posture) returns as soon as the session row
+   * exists with the turn running in the background — the client converges via
+   * push/poll and can watch the live working output. Errors during a detached
+   * turn surface through session state (failSession/interruptSession), never
+   * as an unhandled rejection. Validation errors still throw synchronously.
+   */
+  async start(stageId, opts) {
+    const stage = getStage(stageId);
+    if (!stage) throw new Error(`Unknown CE stage: ${stageId}`);
+    if (!getEnabledStages(this.ctx.settings).includes(stageId)) {
+      throw new Error(`CE stage is not enabled: ${stageId}`);
+    }
+    if (!this.factory) {
+      throw new Error(
+        "Interactive AI sessions are not available (createInteractiveAiSession is only injected on route contexts with the engine loaded)."
+      );
+    }
+    const session = this.store.create({
+      stage: stageId,
+      projectId: opts.projectId ?? null,
+      turnIntervalMs: this.turnTimeoutMs
+    });
+    this.store.appendHistory(session.id, { role: "user", text: opts.openingMessage, at: (/* @__PURE__ */ new Date()).toISOString() });
+    const turn = this.runOpeningTurn(session.id, stage, opts.openingMessage);
+    if (opts.detach) {
+      void turn;
+      return { session: this.requireSession(session.id) };
+    }
+    return turn;
+  }
+  /** Create the live handle and run the opening turn. Never rejects. */
+  async runOpeningTurn(sessionId, stage, openingMessage) {
+    let interactive;
+    try {
+      interactive = await this.factory(this.buildSessionOptions(stage, sessionId));
+    } catch (err) {
+      return { session: this.failSession(sessionId, err), event: void 0 };
+    }
+    this.live.set(sessionId, interactive.session);
+    this.store.update(sessionId, { status: "active" });
+    return this.runTurn(sessionId, () => interactive.session.prompt(openingMessage), interactive.session);
+  }
+  /** Answer the awaiting question and continue the loop (detachable like start). */
+  async answer(sessionId, questionId, response, opts = {}) {
+    const session = this.requireSession(sessionId);
+    if (session.status !== "awaiting_input") {
+      throw new Error(`Session ${sessionId} is not awaiting input (status=${session.status}).`);
+    }
+    if (questionId !== session.currentQuestion?.id) {
+      throw new Error(
+        `Session ${sessionId} is awaiting question "${session.currentQuestion?.id ?? "(none)"}", not "${questionId}".`
+      );
+    }
+    const live = this.live.get(sessionId);
+    if (!live) {
+      throw new Error(`Session ${sessionId} has no live handle in this process; call resume() first.`);
+    }
+    this.store.appendHistory(sessionId, {
+      role: "user",
+      text: JSON.stringify({ answer: response, questionId }),
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.store.update(sessionId, { status: "active", currentQuestion: null });
+    const turn = this.runTurn(sessionId, () => live.answer(questionId, response), live);
+    if (opts.detach) {
+      void turn;
+      return { session: this.requireSession(sessionId) };
+    }
+    return turn;
+  }
+  /**
+   * Resume an `awaiting_input`, `interrupted`, or `error` session — and, crucially,
+   * RE-ESTABLISH a live interactive handle so the resumed session can actually be
+   * answered (Bug 5). After an interrupt/timeout the live handle was disposed and
+   * removed from `this.live`; flipping persisted status back to `awaiting_input`
+   * without a live handle was a dead end (resume → answer → "call resume() first").
+   *
+   * When a question is still pending and no live handle exists, we rehydrate via
+   * the factory and REPLAY the persisted conversation history (opening message +
+   * prior answers) to prime the fresh agent back to the current awaiting question,
+   * repopulating `this.live`. Replay is side-effect-suppressed: it reconstructs
+   * the agent's context only — no artifact writes, no event emits, no history
+   * re-append (the DB already reflects the final state).
+   *
+   * If no factory is available (no live handle can ever be created in this
+   * process), we DO NOT advertise a misleading answerable status: the session is
+   * left `interrupted` with a clear error explaining it can't be continued here.
+   */
+  async resume(sessionId, opts = {}) {
+    const session = this.requireSession(sessionId);
+    if (session.status === "completed") return { session };
+    if (session.status === "awaiting_input" && this.live.has(sessionId)) {
+      return { session };
+    }
+    if (!session.currentQuestion) {
+      const next = this.store.update(sessionId, { status: "active", error: null }) ?? session;
+      return { session: next };
+    }
+    if (this.live.has(sessionId)) {
+      const next = this.store.update(sessionId, { status: "awaiting_input", error: null }) ?? session;
+      return { session: next };
+    }
+    if (!this.factory) {
+      const next = this.store.update(sessionId, {
+        status: "interrupted",
+        error: "Session cannot be continued in this process: interactive AI sessions are unavailable (no factory on this context). Resume from a route context with the engine loaded."
+      }) ?? session;
+      return { session: next };
+    }
+    const rehydration = (async () => {
+      try {
+        await this.rehydrate(session);
+      } catch (err) {
+        return { session: this.interruptSession(sessionId, err) };
+      }
+      const next = this.store.update(sessionId, { status: "awaiting_input", error: null }) ?? session;
+      return { session: next };
+    })();
+    if (opts.detach) {
+      const next = this.store.update(sessionId, { status: "active", error: null }) ?? session;
+      void rehydration;
+      return { session: next };
+    }
+    return rehydration;
+  }
+  /**
+   * Re-create a live interactive session and REPLAY the persisted conversation so
+   * the fresh agent is primed back to the current awaiting question. Side effects
+   * are suppressed: we drain the seam's events to advance the agent's context but
+   * do NOT persist/emit/write — the DB already holds the authoritative final
+   * state. Populates `this.live[session.id]` on success.
+   */
+  async rehydrate(session) {
+    const stage = getStage(session.stage);
+    if (!stage) throw new Error(`Unknown CE stage: ${session.stage}`);
+    this.replaying.add(session.id);
+    try {
+      await this.rehydrateReplay(session, stage);
+    } finally {
+      this.replaying.delete(session.id);
+    }
+  }
+  async rehydrateReplay(session, stage) {
+    const interactive = await this.factory(this.buildSessionOptions(stage, session.id));
+    const live = interactive.session;
+    const userTurns = session.conversationHistory.filter((t) => t.role === "user");
+    try {
+      for (let i = 0; i < userTurns.length; i++) {
+        const turn = userTurns[i];
+        if (i === 0) {
+          await live.prompt(turn.text);
+        } else {
+          const parsed = this.parseAnswerTurn(turn.text);
+          if (!parsed) continue;
+          await live.answer(parsed.questionId, parsed.answer);
+        }
+        await live.nextEvent();
+      }
+    } catch (err) {
+      try {
+        live.dispose();
+      } catch {
+      }
+      throw err;
+    }
+    this.live.set(session.id, live);
+  }
+  /** Parse a serialized `{ answer, questionId }` user turn produced by answer(). */
+  parseAnswerTurn(text) {
+    try {
+      const obj = JSON.parse(text);
+      if (typeof obj?.questionId === "string") {
+        return { questionId: obj.questionId, answer: obj.answer };
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  /** Read-through accessor for routes. */
+  getState(sessionId) {
+    return this.store.get(sessionId);
+  }
+  /**
+   * Discard a session: dispose any live in-process handle (so an in-flight
+   * agent doesn't keep running unobserved) and delete the persisted row.
+   * Returns false when the session doesn't exist. Pipeline-link rows are NOT
+   * touched — board tasks the session landed keep their provenance records.
+   */
+  discard(sessionId) {
+    this.disposeLive(sessionId);
+    return this.store.delete(sessionId);
+  }
+  /**
+   * Run one turn behind a timeout race, persist the resulting event, and on a
+   * turn-level failure auto-save + emit. The `driver` performs the prompt/answer
+   * against the live session; we then pull exactly one event.
+   */
+  async runTurn(sessionId, driver, live) {
+    let event;
+    const watchdog = this.createWatchdog(sessionId);
+    try {
+      event = await Promise.race([
+        (async () => {
+          await driver();
+          return live.nextEvent();
+        })(),
+        watchdog.promise
+      ]);
+    } catch (err) {
+      watchdog.cancel();
+      const session2 = this.interruptSession(sessionId, err);
+      this.disposeLive(sessionId);
+      return { session: session2, event: { type: "error", data: { message: session2.error ?? "interrupted", cause: err } } };
+    }
+    watchdog.cancel();
+    const session = this.applyEvent(sessionId, event);
+    if (event.type === "complete" || event.type === "error") {
+      this.disposeLive(sessionId);
+    }
+    if (event.type === "complete" && session.stage === WORK_STAGE_ID) {
+      await this.landWorkTasks(session, event.data);
+    }
+    return { session, event };
+  }
+  /** Persist a seam event onto the session row + emit the matching observable event. */
+  applyEvent(sessionId, event) {
+    if (event.type === "question" || event.type === "complete" || event.type === "error") {
+      this.flushActivity(sessionId);
+    }
+    switch (event.type) {
+      case "thinking":
+      case "text": {
+        this.store.appendHistory(sessionId, { role: "agent", text: event.data, at: (/* @__PURE__ */ new Date()).toISOString() });
+        const s = this.store.update(sessionId, { status: "active" }) ?? this.requireSession(sessionId);
+        this.ctx.emitEvent(CE_EVENTS.turn, { sessionId, kind: event.type });
+        return s;
+      }
+      case "question": {
+        const q = event.data;
+        this.store.appendHistory(sessionId, {
+          role: "agent",
+          text: JSON.stringify({ question: q }),
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const s = this.store.update(sessionId, { status: "awaiting_input", currentQuestion: q }) ?? this.requireSession(sessionId);
+        this.ctx.emitEvent(CE_EVENTS.question, { sessionId, questionId: q.id });
+        return s;
+      }
+      case "complete": {
+        const artifactPath = this.writeArtifact(sessionId, event.data);
+        this.store.appendHistory(sessionId, {
+          role: "agent",
+          text: JSON.stringify({ complete: true }),
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const s = this.store.update(sessionId, { status: "completed", currentQuestion: null, artifactPath }) ?? this.requireSession(sessionId);
+        this.ctx.emitEvent(CE_EVENTS.completed, { sessionId, artifactPath });
+        return s;
+      }
+      case "error": {
+        const message = event.data.message;
+        const s = this.store.update(sessionId, { status: "error", error: message }) ?? this.requireSession(sessionId);
+        this.ctx.emitEvent(CE_EVENTS.error, { sessionId, message });
+        return s;
+      }
+    }
+  }
+  /**
+   * Work bridge (U7). Read the derived task list from the work stage's
+   * completion payload, create each as a board task tagged CE-originated, and
+   * record a pipeline-link row resolving task→pipeline/stage/artifact. Zero
+   * derived tasks is a clean no-op (no board tasks, no orphan link rows). The
+   * created tasks then run the normal lifecycle — no hooks attached here (U8).
+   */
+  async landWorkTasks(session, data) {
+    const specs = this.extractTaskSpecs(data);
+    if (specs.length === 0) return;
+    const cePipelineId = session.id;
+    const ceStageId = session.stage;
+    const ceArtifactPath = session.artifactPath ?? null;
+    this.pipelineStore.upsertState({
+      cePipelineId,
+      currentStage: ceStageId,
+      status: "running",
+      lastArtifactPath: ceArtifactPath
+    });
+    for (const spec of specs) {
+      const description = spec.description.trim();
+      if (!description) continue;
+      await createCeTaskWithLink(this.ctx.taskStore, this.pipelineStore, {
+        title: spec.title,
+        description,
+        column: spec.column,
+        cePipelineId,
+        ceStageId,
+        ceArtifactPath
+      });
+    }
+  }
+  /** Parse the `{ tasks: [...] }` completion-payload contract; tolerant of shape. */
+  extractTaskSpecs(data) {
+    if (!data || typeof data !== "object") return [];
+    const raw = data.tasks;
+    if (!Array.isArray(raw)) return [];
+    const specs = [];
+    for (const entry of raw) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const description = typeof e.description === "string" ? e.description : "";
+      if (!description.trim()) continue;
+      specs.push({
+        description,
+        title: typeof e.title === "string" ? e.title : void 0,
+        column: typeof e.column === "string" ? e.column : void 0
+      });
+    }
+    return specs;
+  }
+  /** Persist `interrupted` with progress preserved and emit. */
+  interruptSession(sessionId, cause) {
+    this.flushActivity(sessionId);
+    const message = cause instanceof Error ? cause.message : String(cause);
+    const s = this.store.update(sessionId, { status: "interrupted", error: message }) ?? this.requireSession(sessionId);
+    this.ctx.emitEvent(CE_EVENTS.interrupted, { sessionId, message });
+    return s;
+  }
+  /** Persist `error` (session-create failure path) and emit. */
+  failSession(sessionId, cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    const s = this.store.update(sessionId, { status: "error", error: message }) ?? this.requireSession(sessionId);
+    this.ctx.emitEvent(CE_EVENTS.error, { sessionId, message });
+    return s;
+  }
+  /**
+   * Write the stage artifact to its conventional location (R10). Accepts either
+   * a `{ artifact: string }` payload or a raw string. Returns the absolute path.
+   */
+  writeArtifact(sessionId, data) {
+    const session = this.requireSession(sessionId);
+    const stage = getStage(session.stage);
+    const location = stage?.artifactLocation ?? `docs/ce/${session.stage}/`;
+    const content = this.extractArtifactContent(data);
+    const target = location.endsWith("/") ? join2(location, `${session.stage}-${session.id}.md`) : location;
+    const abs = isAbsolute2(target) ? target : join2(this.projectRoot, target);
+    mkdirSync2(dirname2(abs), { recursive: true });
+    writeFileSync(abs, content, "utf-8");
+    return abs;
+  }
+  extractArtifactContent(data) {
+    if (typeof data === "string") return data;
+    if (data && typeof data === "object" && "artifact" in data) {
+      const a = data.artifact;
+      if (typeof a === "string") return a;
+    }
+    return JSON.stringify(data, null, 2);
+  }
+  requireSession(sessionId) {
+    const s = this.store.get(sessionId);
+    if (!s) throw new Error(`CE session not found: ${sessionId}`);
+    return s;
+  }
+  disposeLive(sessionId) {
+    const live = this.live.get(sessionId);
+    if (live) {
+      try {
+        live.dispose();
+      } catch {
+      }
+      this.live.delete(sessionId);
+    }
+    this.activity.delete(sessionId);
+    this.lastProgressAt.delete(sessionId);
+    this.lastProgressEmitAt.delete(sessionId);
+  }
+};
+
+// ../../plugins/fusion-plugin-compound-engineering/src/routes/route-helpers.ts
+function asString2(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/routes/session-routes.ts
+var orchestratorCache = /* @__PURE__ */ new WeakMap();
+function getOrchestrator(ctx) {
+  const key = ctx.taskStore;
+  const cached = orchestratorCache.get(key);
+  if (cached) return cached;
+  const orch = new CeOrchestrator({ ctx });
+  orchestratorCache.set(key, orch);
+  return orch;
+}
+function badRequest(message) {
+  return { status: 400, body: { error: message } };
+}
+function createSessionRoutes() {
+  return [
+    {
+      method: "POST",
+      path: "/sessions",
+      description: "Start an interactive CE stage session.",
+      handler: async (req, ctx) => {
+        const body = req.body;
+        const stageId = asString2(body?.stage);
+        const openingMessage = asString2(body?.message) ?? "";
+        if (!stageId) return badRequest("`stage` is required");
+        const orch = getOrchestrator(ctx);
+        try {
+          const result = await orch.start(stageId, {
+            openingMessage,
+            projectId: asString2(body?.projectId) ?? null,
+            detach: true
+          });
+          return { status: 201, body: { session: result.session } };
+        } catch (err) {
+          return { status: 400, body: { error: err instanceof Error ? err.message : String(err) } };
+        }
+      }
+    },
+    {
+      method: "POST",
+      path: "/sessions/:id/answer",
+      description: "Answer the awaiting question and continue the session.",
+      handler: async (req, ctx) => {
+        const request = req;
+        const id = request.params.id;
+        const body = request.body;
+        const questionId = asString2(body?.questionId);
+        if (!questionId) return badRequest("`questionId` is required");
+        if (!("response" in (body ?? {}))) return badRequest("`response` is required");
+        const orch = getOrchestrator(ctx);
+        try {
+          const result = await orch.answer(id, questionId, body.response, {
+            detach: true
+          });
+          return { status: 200, body: { session: result.session } };
+        } catch (err) {
+          return { status: 409, body: { error: err instanceof Error ? err.message : String(err) } };
+        }
+      }
+    },
+    {
+      method: "POST",
+      path: "/sessions/:id/resume",
+      description: "Resume an awaiting_input or interrupted session to its current question.",
+      handler: async (req, ctx) => {
+        const id = req.params.id;
+        const orch = getOrchestrator(ctx);
+        try {
+          const result = await orch.resume(id, { detach: true });
+          return { status: 200, body: { session: result.session } };
+        } catch (err) {
+          return { status: 404, body: { error: err instanceof Error ? err.message : String(err) } };
+        }
+      }
+    },
+    {
+      method: "GET",
+      path: "/sessions/:id",
+      description: "Get current session state, including in-flight working output (liveActivity).",
+      handler: async (req, ctx) => {
+        const id = req.params.id;
+        const session = getCeSessionStore(ctx).get(id);
+        if (!session) return { status: 404, body: { error: `Session ${id} not found` } };
+        const liveActivity = getOrchestrator(ctx).getLiveActivity(id);
+        return {
+          status: 200,
+          body: { session: liveActivity.length > 0 ? { ...session, liveActivity } : session }
+        };
+      }
+    },
+    {
+      method: "GET",
+      path: "/sessions",
+      description: "List CE sessions (optionally filtered by status/stage).",
+      handler: async (req, ctx) => {
+        const query = req.query ?? {};
+        const status = asCeSessionStatus(typeof query.status === "string" ? query.status : void 0);
+        const stage = typeof query.stage === "string" ? query.stage : void 0;
+        const sessions = getCeSessionStore(ctx).list({ status, stage });
+        return { status: 200, body: { sessions } };
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/sessions/:id",
+      description: "Discard a CE session (disposes any live handle, deletes the row).",
+      handler: async (req, ctx) => {
+        const id = req.params.id;
+        const removed = getOrchestrator(ctx).discard(id);
+        if (!removed) return { status: 404, body: { error: `Session ${id} not found` } };
+        return { status: 200, body: { deleted: true } };
+      }
+    },
+    {
+      // U7 work bridge: observe the board tasks a CE pipeline (session) landed,
+      // via their link records (the addressable back-reference, FN-5719). The
+      // session id IS the pipeline id. Outbound-only in U7; U8 layers state.
+      method: "GET",
+      path: "/sessions/:id/links",
+      description: "List the CE pipeline-link records (work\u2192board) for a session/pipeline.",
+      handler: async (req, ctx) => {
+        const id = req.params.id;
+        const links = getCePipelineStore(ctx).listByPipeline(id);
+        return { status: 200, body: { links } };
+      }
+    }
+  ];
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/artifacts/discovery.ts
+import { accessSync, constants, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join3, relative, sep as sep2 } from "node:path";
+var CONVENTIONAL_LOCATIONS = [
+  { stage: "strategy", label: "Strategy", path: "STRATEGY.md", kind: "file" },
+  { stage: "ideation", label: "Ideation", path: "docs/ideation", kind: "directory" },
+  { stage: "brainstorm", label: "Brainstorms", path: "docs/brainstorms", kind: "directory" },
+  { stage: "plan", label: "Plans", path: "docs/plans", kind: "directory" },
+  { stage: "solution", label: "Solutions", path: "docs/solutions", kind: "directory" },
+  { stage: "concepts", label: "Concepts", path: "CONCEPTS.md", kind: "file" }
+];
+var MAX_ARTIFACT_BYTES = 2e6;
+function toPosix(p) {
+  return p.split(sep2).join("/");
+}
+function isWithin(root, locationAbs, candidate) {
+  const relToLocation = relative(locationAbs, candidate);
+  if (relToLocation.startsWith("..") || isAbsolute3(relToLocation)) return false;
+  const relToRoot = relative(root, candidate);
+  if (relToRoot.startsWith("..") || isAbsolute3(relToRoot)) return false;
+  return true;
+}
+function makeId(stage, relPath) {
+  return `${stage}:${relPath}`;
+}
+function makeError(stage, relPath, message) {
+  return {
+    id: makeId(stage, relPath),
+    stage,
+    path: relPath,
+    name: relPath.split("/").pop() ?? relPath,
+    kind: "error",
+    error: message
+  };
+}
+function readArtifactEntry(stage, root, locationAbs, abs, relPath) {
+  const name = relPath.split("/").pop() ?? relPath;
+  if (!isWithin(root, locationAbs, abs)) {
+    return makeError(stage, relPath, "Path is outside its conventional location");
+  }
+  try {
+    const st = statSync(abs);
+    if (st.size > MAX_ARTIFACT_BYTES) {
+      return makeError(stage, relPath, `Artifact too large to read (${st.size} bytes)`);
+    }
+    accessSync(abs, constants.R_OK);
+    return {
+      id: makeId(stage, relPath),
+      stage,
+      path: relPath,
+      name,
+      size: st.size,
+      updatedAt: st.mtimeMs,
+      kind: "artifact"
+    };
+  } catch (err) {
+    return makeError(stage, relPath, err instanceof Error ? err.message : String(err));
+  }
+}
+function sortEntries(entries) {
+  return [...entries].sort((a, b) => {
+    if (a.kind !== b.kind) return a.kind === "artifact" ? -1 : 1;
+    if (a.kind === "artifact" && b.kind === "artifact") return b.updatedAt - a.updatedAt;
+    return a.name.localeCompare(b.name);
+  });
+}
+function discoverLocation(root, loc) {
+  const locationAbs = join3(root, loc.path);
+  const entries = [];
+  let present = false;
+  let st;
+  try {
+    st = statSync(locationAbs);
+    present = true;
+  } catch {
+    return { stage: loc.stage, label: loc.label, present: false, entries: [] };
+  }
+  if (loc.kind === "file") {
+    if (st.isFile()) {
+      entries.push(readArtifactEntry(loc.stage, root, locationAbs, locationAbs, toPosix(loc.path)));
+    } else {
+      entries.push(
+        makeError(
+          loc.stage,
+          toPosix(loc.path),
+          "Expected a file at the conventional location but found a directory"
+        )
+      );
+    }
+    return { stage: loc.stage, label: loc.label, present, entries: sortEntries(entries) };
+  }
+  let names = [];
+  try {
+    if (!st.isDirectory()) {
+      entries.push(
+        makeError(
+          loc.stage,
+          toPosix(loc.path),
+          "Expected a directory at the conventional location but found a file"
+        )
+      );
+      return { stage: loc.stage, label: loc.label, present, entries: sortEntries(entries) };
+    }
+    names = readdirSync(locationAbs);
+  } catch (err) {
+    entries.push(makeError(loc.stage, toPosix(loc.path), err instanceof Error ? err.message : String(err)));
+    return { stage: loc.stage, label: loc.label, present, entries: sortEntries(entries) };
+  }
+  for (const childName of names) {
+    if (childName.startsWith(".")) continue;
+    if (!childName.toLowerCase().endsWith(".md")) continue;
+    const abs = join3(locationAbs, childName);
+    const relPath = toPosix(join3(loc.path, childName));
+    let childStat;
+    try {
+      childStat = statSync(abs);
+    } catch (err) {
+      entries.push(makeError(loc.stage, relPath, err instanceof Error ? err.message : String(err)));
+      continue;
+    }
+    if (!childStat.isFile()) continue;
+    entries.push(readArtifactEntry(loc.stage, root, locationAbs, abs, relPath));
+  }
+  return { stage: loc.stage, label: loc.label, present, entries: sortEntries(entries) };
+}
+function discoverArtifacts(projectRoot) {
+  const root = projectRoot;
+  const groups = CONVENTIONAL_LOCATIONS.map((loc) => discoverLocation(root, loc));
+  let totalArtifacts = 0;
+  let totalErrors = 0;
+  for (const g of groups) {
+    for (const e of g.entries) {
+      if (e.kind === "artifact") totalArtifacts += 1;
+      else totalErrors += 1;
+    }
+  }
+  return { groups, totalArtifacts, totalErrors };
+}
+function readArtifactById(projectRoot, id) {
+  const sepIdx = id.indexOf(":");
+  if (sepIdx <= 0) return void 0;
+  const stage = id.slice(0, sepIdx);
+  const relPath = id.slice(sepIdx + 1);
+  const loc = CONVENTIONAL_LOCATIONS.find((l) => l.stage === stage);
+  if (!loc) return void 0;
+  const locationAbs = join3(projectRoot, loc.path);
+  const abs = join3(projectRoot, relPath);
+  if (loc.kind === "file") {
+    if (toPosix(relPath) !== toPosix(loc.path)) return void 0;
+  } else if (!isWithin(projectRoot, locationAbs, abs)) {
+    return void 0;
+  }
+  if (loc.kind === "directory") {
+    const rel = relative(locationAbs, abs);
+    if (rel.includes(sep2) || rel.startsWith("..") || !rel.toLowerCase().endsWith(".md")) {
+      return void 0;
+    }
+  }
+  let content;
+  let mtimeMs;
+  let size;
+  try {
+    const st = statSync(abs);
+    if (!st.isFile()) return { error: "Artifact is not a readable file" };
+    if (st.size > MAX_ARTIFACT_BYTES) return { error: `Artifact too large to read (${st.size} bytes)` };
+    mtimeMs = st.mtimeMs;
+    size = st.size;
+  } catch (err) {
+    if (err?.code === "ENOENT") return void 0;
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+  try {
+    content = readFileSync2(abs, "utf8");
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+  const name = relPath.split("/").pop() ?? relPath;
+  return {
+    artifact: {
+      id,
+      stage,
+      path: toPosix(relPath),
+      name,
+      size,
+      updatedAt: mtimeMs,
+      kind: "artifact"
+    },
+    content
+  };
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/routes/artifact-routes.ts
+async function resolveProjectRoot(ctx, projectId) {
+  if (projectId && ctx.resolveProjectTaskStore) {
+    try {
+      const store = await ctx.resolveProjectTaskStore(projectId);
+      return store.getRootDir();
+    } catch {
+    }
+  }
+  return ctx.taskStore.getRootDir();
+}
+function escapeHtml(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function renderArtifactDocument(name, content) {
+  const escaped = escapeHtml(content);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${escapeHtml(name)}</title>
+<style>
+:root { color-scheme: light dark; }
+* { box-sizing: border-box; }
+body { margin: 0; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; line-height: 1.5; background: #ffffff; color: #1a1a1a; }
+@media (prefers-color-scheme: dark) { body { background: #16181d; color: #e6e6e6; } }
+.artifact-doc { padding: 1.25rem 1.5rem; }
+.artifact-doc h1 { font-size: 1.1rem; margin: 0 0 1rem; font-family: ui-sans-serif, system-ui, sans-serif; }
+.artifact-body { white-space: pre-wrap; word-break: break-word; margin: 0; font-size: 0.85rem; }
+</style>
+</head>
+<body>
+<main class="artifact-doc" data-section="artifact">
+<h1 data-section="title">${escapeHtml(name)}</h1>
+<pre class="artifact-body" data-section="content">${escaped}</pre>
+</main>
+</body>
+</html>`;
+}
+function createArtifactRoutes() {
+  return [
+    {
+      method: "GET",
+      path: "/artifacts",
+      description: "List discovered CE artifacts grouped by stage.",
+      handler: async (req, ctx) => {
+        const query = req.query ?? {};
+        const projectId = asString2(query.projectId);
+        const root = await resolveProjectRoot(ctx, projectId);
+        const result = discoverArtifacts(root);
+        return { status: 200, body: result };
+      }
+    },
+    {
+      method: "GET",
+      path: "/artifacts/:id",
+      description: "Read a single CE artifact's raw content (JSON).",
+      handler: async (req, ctx) => {
+        const request = req;
+        const id = decodeURIComponent(request.params.id);
+        const projectId = asString2(request.query?.projectId);
+        const root = await resolveProjectRoot(ctx, projectId);
+        const result = readArtifactById(root, id);
+        if (!result) return { status: 404, body: { error: `Artifact ${id} not found` } };
+        if ("error" in result) return { status: 422, body: { error: result.error } };
+        return { status: 200, body: { artifact: result.artifact, content: result.content } };
+      }
+    },
+    {
+      method: "GET",
+      path: "/artifacts/:id/preview.html",
+      description: "Read a single CE artifact rendered as a self-contained HTML document.",
+      handler: async (req, ctx) => {
+        const request = req;
+        const id = decodeURIComponent(request.params.id);
+        const projectId = asString2(request.query?.projectId);
+        const root = await resolveProjectRoot(ctx, projectId);
+        const result = readArtifactById(root, id);
+        if (!result) return { status: 404, body: { error: `Artifact ${id} not found` } };
+        if ("error" in result) return { status: 422, body: { error: result.error } };
+        return {
+          status: 200,
+          contentType: "text/html; charset=utf-8",
+          body: renderArtifactDocument(result.artifact.name, result.content)
+        };
+      }
+    }
+  ];
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/sync/reconciler.ts
+var TERMINAL_COLUMNS = /* @__PURE__ */ new Set(["in-review", "done"]);
+function stageOrder() {
+  return listStages().map((s) => s.stageId);
+}
+function nextStageAfter(stageId) {
+  const order = stageOrder();
+  const idx = order.indexOf(stageId);
+  if (idx < 0 || idx >= order.length - 1) return void 0;
+  return order[idx + 1];
+}
+var CeReconciler = class {
+  ctx;
+  store;
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.store = getCePipelineStore(ctx);
+  }
+  /**
+   * Drain the queue AND re-derive missed transitions from live board state, then
+   * apply any pipeline advancement (with outbound board propagation). Idempotent:
+   * running it twice is a no-op once everything has converged.
+   */
+  async reconcile() {
+    const result = { drained: 0, advanced: 0, tasksCreated: 0, inspected: 0 };
+    const pending = this.store.listPendingSync();
+    for (const entry of pending) {
+      this.store.markSyncProcessed(entry.id);
+      result.drained++;
+    }
+    const states = this.store.listAllState();
+    for (const state of states) {
+      result.inspected++;
+      const advanced = await this.reconcileOne(state);
+      if (advanced) {
+        result.advanced++;
+        if (advanced.created) result.tasksCreated++;
+      }
+    }
+    return result;
+  }
+  /**
+   * Re-derive whether ONE pipeline should advance by reading the live board
+   * column of its current-stage task(s). Board is authoritative for task state;
+   * we never write the task column from here for the current stage.
+   */
+  async reconcileOne(state) {
+    if (state.status === "completed") return void 0;
+    const links = this.store.listByPipeline(state.cePipelineId);
+    const currentStageLinks = links.filter((l) => l.ceStageId === state.currentStage);
+    if (currentStageLinks.length === 0) return void 0;
+    const tasks = await this.loadTasks(currentStageLinks);
+    if (tasks.length === 0) return void 0;
+    const existing = tasks.filter((t) => t != null);
+    if (existing.length === 0) {
+      return void 0;
+    }
+    const allTerminal = existing.every((t) => TERMINAL_COLUMNS.has(t.column));
+    if (!allTerminal) {
+      if (state.status !== "running") {
+        this.store.transitionState(state.cePipelineId, { status: "running" });
+      }
+      return void 0;
+    }
+    const next = nextStageAfter(state.currentStage);
+    if (!next) {
+      this.store.transitionState(state.cePipelineId, { status: "completed" });
+      this.ctx.emitEvent("compound-engineering:pipeline-completed", {
+        cePipelineId: state.cePipelineId,
+        stage: state.currentStage
+      });
+      return { created: false };
+    }
+    const created = await this.advance(state, next, links);
+    return { created };
+  }
+  /**
+   * Advance the pipeline to `nextStage` (CE-owned write) and propagate OUTBOUND
+   * by creating the next-stage board task (board-owned write on a NEW row).
+   * Idempotent: if a link for the next stage already exists, we don't duplicate.
+   */
+  async advance(state, nextStage, links) {
+    const already = links.some((l) => l.ceStageId === nextStage);
+    if (already) {
+      this.store.transitionState(state.cePipelineId, {
+        currentStage: nextStage,
+        status: "running"
+      });
+      return false;
+    }
+    const task = await createCeTaskWithLink(this.ctx.taskStore, this.store, {
+      title: `CE ${nextStage}: continue pipeline`,
+      description: `Continue the compound-engineering pipeline at the "${nextStage}" stage.`,
+      cePipelineId: state.cePipelineId,
+      ceStageId: nextStage,
+      ceArtifactPath: state.lastArtifactPath
+    });
+    this.store.transitionState(state.cePipelineId, {
+      currentStage: nextStage,
+      status: "awaiting_board"
+    });
+    this.ctx.emitEvent("compound-engineering:pipeline-advanced", {
+      cePipelineId: state.cePipelineId,
+      fromStage: state.currentStage,
+      toStage: nextStage,
+      taskId: task.id
+    });
+    return true;
+  }
+  /** Load the live board tasks for a set of links (board-authoritative read). */
+  async loadTasks(links) {
+    const out = [];
+    for (const link of links) {
+      try {
+        const task = await this.ctx.taskStore.getTask(link.taskId);
+        out.push(task ?? void 0);
+      } catch {
+        out.push(void 0);
+      }
+    }
+    return out;
+  }
+};
+async function reconcileCePipelines(ctx) {
+  return new CeReconciler(ctx).reconcile();
+}
+
+// ../../plugins/fusion-plugin-compound-engineering/src/index.ts
+var plugin = definePlugin({
+  manifest: {
+    id: "fusion-plugin-compound-engineering",
+    name: "Compound Engineering",
+    version: "0.1.0",
+    description: "A dedicated dashboard surface for compound-engineering artifacts and interactive ce-* sessions.",
+    author: "Fusion Team",
+    fusionVersion: ">=0.1.0",
+    skills: COMPOUND_ENGINEERING_SKILLS.map((s) => ({ skillId: s.skillId, name: s.name })),
+    settingsSchema
+  },
+  state: "installed",
+  skills: COMPOUND_ENGINEERING_SKILLS,
+  hooks: {
+    // Idempotent DDL for the plugin-local CE tables (ce_sessions). Runs against
+    // the same DB route handlers reach via ctx.taskStore.getDatabase() (U5).
+    onSchemaInit: ensureCeSchema,
+    // INBOUND board→pipeline sync (U8 / FN-5719). The 5s hook budget
+    // (plugin-runner invokeHookSafe) means these MUST be fast: resolve the link,
+    // ENQUEUE a sync signal, and return. Heavy advancement (board reads, outbound
+    // task creation) happens in the reconciler, NOT inline here. A reconcile
+    // drain is fired-and-forgotten (never awaited) so a slow sweep cannot blow
+    // the hook budget; correctness does not depend on it firing because the next
+    // reconcile() sweep re-derives the transition from board truth.
+    onTaskMoved: (task, fromColumn, toColumn, ctx) => {
+      const store = getCePipelineStore(ctx);
+      const link = store.findByTaskId(task.id);
+      if (!link) return;
+      store.enqueueSync({
+        cePipelineId: link.cePipelineId,
+        taskId: task.id,
+        reason: "task_moved",
+        fromColumn,
+        toColumn
+      });
+      if (!getReconcileOnHooks(ctx.settings)) return;
+      void Promise.resolve().then(() => reconcileCePipelines(ctx)).catch((err) => ctx.logger.warn(`CE reconcile (onTaskMoved) failed: ${String(err)}`));
+    },
+    onTaskCompleted: (task, ctx) => {
+      const store = getCePipelineStore(ctx);
+      const link = store.findByTaskId(task.id);
+      if (!link) return;
+      store.enqueueSync({
+        cePipelineId: link.cePipelineId,
+        taskId: task.id,
+        reason: "task_completed",
+        toColumn: "done"
+      });
+      if (!getReconcileOnHooks(ctx.settings)) return;
+      void Promise.resolve().then(() => reconcileCePipelines(ctx)).catch((err) => ctx.logger.warn(`CE reconcile (onTaskCompleted) failed: ${String(err)}`));
+    },
+    // Install the bundled, pinned ce-* SKILL.md files into a plugin-local,
+    // discoverable directory on load. The engine ingests
+    // PluginSkillContribution only as a name; physical discovery requires the
+    // files to exist on a path it scans (U2 finding). Install is idempotent
+    // (skip-if-exists) and guarded to never touch a global ~/.claude/skills.
+    onLoad: async (ctx) => {
+      try {
+        const { targetRoot, results } = installBundledCeSkills();
+        const installed = results.filter((r) => r.outcome === "installed").length;
+        const errored = results.filter((r) => r.outcome === "error");
+        if (errored.length > 0) {
+          ctx.logger.warn(
+            `Compound Engineering: ${errored.length} skill(s) failed to install: ${errored.map((e) => `${e.skillId} (${e.reason})`).join(", ")}`
+          );
+        }
+        ctx.logger.info(
+          `Compound Engineering skills ready \u2014 installed=${installed} target=${targetRoot}`
+        );
+        ctx.emitEvent("compound-engineering:skills-installed", { targetRoot, results });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.logger.error(`Compound Engineering skill install failed: ${message}`);
+      }
+    }
+  },
+  routes: [...createSessionRoutes(), ...createArtifactRoutes()],
+  dashboardViews: [
+    {
+      viewId: "compound-engineering",
+      label: "Compound Engineering",
+      componentPath: "./dashboard-view",
+      icon: "Sparkles",
+      placement: "primary",
+      order: 36
+    }
+  ]
+});
+var index_default = plugin;
+export {
+  CE_PLUGIN_ID,
+  CE_WORK_SOURCE_TYPE,
+  COMPOUND_ENGINEERING_SKILLS,
+  CeOrchestrator,
+  CePipelineStore,
+  CeReconciler,
+  CeSessionStore,
+  WORK_STAGE_ID,
+  index_default as default,
+  ensureCeSchema,
+  getCePipelineStore,
+  getCeSessionStore,
+  getDefaultModelId,
+  getDefaultProvider,
+  getEnabledStages,
+  getReconcileIntervalMinutes,
+  getReconcileOnHooks,
+  getStage,
+  installBundledCeSkills,
+  isPluginLocalPath,
+  listStages,
+  reconcileCePipelines,
+  registerStage,
+  resolveBundledSkillsRoot,
+  resolveDefaultInstallTargetRoot,
+  settingsSchema
+};