agent-canvas 0.1.13 → 0.1.15

package/daemon/src/compiler.ts

@@ -1,6 +1,8 @@
 import { writeFileSync, unlinkSync, readFileSync } from "fs";
 import { join } from "path";
 import { randomUUID } from "crypto";
+import { h, Fragment } from "preact";
+import renderToString from "preact-render-to-string";
 import { COMPILE_TEMP_DIR } from "./paths";
 
 type CompileResult =
@@ -15,6 +17,96 @@ const { Section, Item, Task, FilePreview, CodeBlock, Callout,
         Markdown, useFeedback, useAnnotations } = C;
 `;
 
+// --- Validation via Preact --------------------------------------------------
+// After Bun.build() succeeds we strip ESM syntax from the compiled output,
+// provide Preact as the React implementation with lightweight stub components,
+// and actually render the component tree.  Any runtime error (undefined vars,
+// broken template literals, …) is caught and reported back to the CLI.
+
+/** jsxDEV(type, props, key, isStaticChildren, source, self) → VNode */
+function mockJsxDEV(type: any, props: any, key?: any) {
+  const { children, ...rest } = props || {};
+  return h(type, { ...rest, key }, children);
+}
+
+/** Passthrough component — just renders its children */
+const Stub = ({ children }: any) => h(Fragment, null, children);
+
+const STUB_COMPONENTS: Record<string, any> = {};
+for (const name of [
+  "Section", "Item", "Task", "FilePreview", "CodeBlock", "Callout",
+  "Mermaid", "Table", "Priority", "Checklist", "Note", "Diff",
+  "Choice", "MultiChoice", "UserInput", "RangeInput", "ImageView", "Markdown",
+]) {
+  STUB_COMPONENTS[name] = Stub;
+}
+// Hook stubs — return shapes that won't blow up when destructured
+STUB_COMPONENTS.useFeedback = () => ({ submit: () => {}, value: null });
+STUB_COMPONENTS.useAnnotations = () => ({ annotations: [], addAnnotation: () => {} });
+
+const MOCK_REACT = {
+  createElement: h,
+  Fragment,
+  useState: (init: any) => [init, () => {}],
+  useEffect: () => {},
+  useRef: (init: any) => ({ current: init }),
+  useMemo: (fn: any) => fn(),
+  useCallback: (fn: any) => fn,
+  useReducer: (r: any, init: any) => [init, () => {}],
+  useContext: () => ({}),
+  createContext: () => ({ Provider: Stub, Consumer: Stub }),
+  useLayoutEffect: () => {},
+  useImperativeHandle: () => {},
+  useDebugValue: () => {},
+  useDeferredValue: (v: any) => v,
+  useTransition: () => [false, (fn: any) => fn()],
+  useId: () => "mock",
+  useSyncExternalStore: (sub: any, get: any) => get(),
+  memo: (c: any) => c,
+  forwardRef: (c: any) => c,
+  lazy: (c: any) => c,
+  Children: { map: (c: any, fn: any) => (Array.isArray(c) ? c : [c]).map(fn), toArray: (c: any) => (Array.isArray(c) ? c : [c]) },
+  isValidElement: () => true,
+  cloneElement: h,
+  Suspense: Stub,
+  StrictMode: Stub,
+};
+
+function validateCompiledPlan(js: string): { ok: true } | { ok: false; error: string } {
+  let code = js;
+
+  // Strip ESM import statements
+  code = code.replace(/import\s+\w+\s+from\s+"[^"]+";?/g, "");
+  code = code.replace(/import\s+\*\s+as\s+\w+\s+from\s+"[^"]+";?/g, "");
+  code = code.replace(/import\s*\{[^}]*\}\s*from\s+"[^"]+";?/g, "");
+
+  // Strip export, extract default name
+  let defaultName: string | null = null;
+  code = code.replace(/export\s*\{\s*(\w+)\s+as\s+default\s*\};?/g, (_, name) => {
+    defaultName = name;
+    return "";
+  });
+  if (!defaultName) {
+    code = code.replace(/export\s+default\s+(\w+);?/g, (_, name) => {
+      defaultName = name;
+      return "";
+    });
+  }
+
+  const callDefault = defaultName
+    ? `\nreturn typeof ${defaultName} === "function" ? ${defaultName}() : null;`
+    : "\nreturn null;";
+
+  try {
+    const fn = new Function("React", "C", "jsxDEV", "jsx", "Fragment", code + callDefault);
+    const vnode = fn(MOCK_REACT, STUB_COMPONENTS, mockJsxDEV, mockJsxDEV, Fragment);
+    if (vnode) renderToString(vnode);
+    return { ok: true };
+  } catch (e: any) {
+    return { ok: false, error: e?.message || String(e) };
+  }
+}
+
 export async function compilePlan(jsx: string, projectRoot?: string): Promise<CompileResult> {
   // Resolve file contents at compile time
   if (projectRoot) {
@@ -49,6 +141,10 @@ export async function compilePlan(jsx: string, projectRoot?: string): Promise<Co
       }
 
       const js = await result.outputs[0].text();
+      const validation = validateCompiledPlan(js);
+      if (!validation.ok) {
+        return { ok: false, error: `Runtime error: ${validation.error}` };
+      }
       return { ok: true, js };
     } catch {
       // Bun.build() can throw "Unknown Error, TODO" in long-running processes
@@ -78,6 +174,10 @@ async function compilePlanSubprocess(tmpFile: string): Promise<CompileResult> {
   }
   try {
     const js = readFileSync(outFile, "utf-8");
+    const validation = validateCompiledPlan(js);
+    if (!validation.ok) {
+      return { ok: false, error: `Runtime error: ${validation.error}` };
+    }
     return { ok: true, js };
   } finally {
     try { unlinkSync(outFile); } catch {}

package/daemon/src/handlers/api.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from "fs";
+import { readFileSync, readdirSync, existsSync } from "fs";
 import type { SessionManager } from "../session";
 import { compilePlan } from "../compiler";
 import { watchSession } from "../watcher";
@@ -11,24 +11,36 @@ export interface ApiContext {
   port: number;
 }
 
-function readRevisionJsx(sessionManager: SessionManager, sessionId: string, rev: number): string | null {
-  try {
-    const path = sessionManager.getRevisionJsxPath(sessionId, rev);
-    return readFileSync(path, "utf-8");
-  } catch {
-    return null;
-  }
-}
-
 export function createApiHandlers(ctx: ApiContext): Route[] {
   const { sessionManager, broadcastPlanUpdate, port } = ctx;
 
+  /**
+   * Read *.jsx canvas files from a directory.
+   * Returns a Map of filename -> JSX content.
+   */
+  function resolveCanvasFiles(directory: string): Map<string, string> | null {
+    if (!existsSync(directory)) return null;
+    const files = readdirSync(directory).filter(f => f.endsWith(".jsx")).sort();
+    if (files.length === 0) return null;
+    const map = new Map<string, string>();
+    for (const f of files) {
+      map.set(f, readFileSync(`${directory}/${f}`, "utf-8"));
+    }
+    return map;
+  }
+
   async function handlePlanPost(req: Request, _url: URL, match: URLPatternResult): Promise<Response> {
     const sessionId = match.pathname.groups.id!;
     try {
       const body = await req.json();
-      const { jsx, projectRoot, label, sourceFile, response } = body;
-      if (!jsx) return jsonResponse({ error: "Missing jsx" }, 400);
+
+      if (!body.directory) {
+        return jsonResponse({ error: "Missing directory" }, 400);
+      }
+      const canvasFiles = resolveCanvasFiles(body.directory);
+      if (!canvasFiles) {
+        return jsonResponse({ error: "No .jsx files found in directory" }, 400);
+      }
 
       const unconsumed = sessionManager.getLatestUnconsumedFeedback(sessionId);
       if (unconsumed) {
@@ -41,12 +53,26 @@ export function createApiHandlers(ctx: ApiContext): Route[] {
         }, 409);
       }
 
+      const projectRoot = body.projectRoot || process.cwd();
       const isNew = !sessionManager.get(sessionId);
-      const session = sessionManager.upsert(sessionId, jsx, projectRoot || process.cwd(), label, sourceFile, response);
+      const session = sessionManager.upsert(sessionId, canvasFiles, projectRoot, body.label, body.response);
+
+      // Compile all canvas files in parallel
+      const errors: Record<string, string> = {};
+      let anyOk = false;
+      await Promise.all(
+        [...canvasFiles.entries()].map(async ([filename, jsx]) => {
+          const result = await compilePlan(jsx, session.projectRoot);
+          if (result.ok) {
+            sessionManager.saveCompiled(sessionId, filename, result.js, session.currentRevision);
+            anyOk = true;
+          } else {
+            errors[filename] = result.error;
+          }
+        }),
+      );
 
-      const result = await compilePlan(jsx, session.projectRoot);
-      if (result.ok) {
-        sessionManager.saveCompiled(sessionId, result.js, session.currentRevision);
+      if (anyOk) {
         broadcastPlanUpdate(sessionId);
       }
 
@@ -54,39 +80,47 @@ export function createApiHandlers(ctx: ApiContext): Route[] {
 
       const browserUrl = `http://localhost:${port}/s/${sessionId}`;
       return jsonResponse({
-        ok: result.ok,
+        ok: anyOk,
         browserUrl,
         isNew,
         revision: session.currentRevision,
-        error: result.ok ? undefined : result.error,
+        sessionId,
+        canvasFiles: [...canvasFiles.keys()],
+        ...(Object.keys(errors).length > 0 ? { errors } : {}),
       });
     } catch (e: any) {
       return jsonResponse({ error: e.message }, 500);
     }
   }
 
-  async function handlePlanJs(_req: Request, url: URL, match: URLPatternResult): Promise<Response> {
+  async function handleCanvasJs(_req: Request, url: URL, match: URLPatternResult): Promise<Response> {
     const sessionId = match.pathname.groups.id!;
+    const jsFilename = match.pathname.groups.filename!;
+    const jsxFilename = jsFilename.replace(/\.js$/, ".jsx");
     const revParam = url.searchParams.get("rev");
     const rev = revParam ? parseInt(revParam, 10) : undefined;
 
-    let compiled = sessionManager.getCompiled(sessionId, rev);
+    let compiled = sessionManager.getCompiled(sessionId, jsxFilename, rev);
 
     if (!compiled && rev) {
       const session = sessionManager.get(sessionId);
       if (session) {
-        const jsx = readRevisionJsx(sessionManager, sessionId, rev);
+        const jsx = sessionManager.readRevisionJsx(sessionId, rev, jsxFilename);
         if (jsx) {
           const result = await compilePlan(jsx, session.projectRoot);
           if (result.ok) {
-            sessionManager.saveCompiled(sessionId, result.js, rev);
+            sessionManager.saveCompiled(sessionId, jsxFilename, result.js, rev);
             compiled = result.js;
+          } else {
+            console.warn(`[canvas.js] compilation failed for ${sessionId}/${jsxFilename} rev ${rev}: ${result.error}`);
           }
+        } else {
+          console.warn(`[canvas.js] no JSX found for ${sessionId}/${jsxFilename} rev ${rev}`);
         }
       }
     }
 
-    if (!compiled) return jsonResponse({ error: "No compiled plan" }, 404);
+    if (!compiled) return jsonResponse({ error: "No compiled canvas" }, 404);
     return new Response(compiled, {
       headers: {
         "Content-Type": "application/javascript",
@@ -108,6 +142,7 @@ export function createApiHandlers(ctx: ApiContext): Route[] {
       projectRoot: session.projectRoot,
       currentRevision: session.currentRevision,
       revisions: session.revisions,
+      canvasFiles: session.canvasFiles,
       createdAt: session.createdAt,
       updatedAt: session.updatedAt,
     });
@@ -141,7 +176,7 @@ export function createApiHandlers(ctx: ApiContext): Route[] {
   return [
     { method: "GET", pattern: new URLPattern({ pathname: "/health" }), handler: handleHealth },
     { method: "POST", pattern: new URLPattern({ pathname: "/api/session/:id/plan" }), handler: handlePlanPost },
-    { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/plan.js" }), handler: handlePlanJs },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/canvas/:filename" }), handler: handleCanvasJs },
     { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/meta" }), handler: handleMeta },
     { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/revision/:rev/feedback" }), handler: handleFeedbackGet },
     { method: "POST", pattern: new URLPattern({ pathname: "/api/session/:id/feedback/consume" }), handler: handleFeedbackConsume },

package/daemon/src/session.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, rmSync, renameSync } from "fs";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, rmSync, renameSync, copyFileSync } from "fs";
 import { join } from "path";
 import { SESSIONS_DIR } from "./paths";
 
@@ -7,21 +7,25 @@ export interface DiffStats {
   removed: number;
 }
 
+export interface CanvasFileInfo {
+  filename: string;
+  diffStats?: DiffStats;
+}
+
 export interface RevisionInfo {
   revision: number;
   label?: string;
-  sourceFile?: string;
+  canvasFiles: CanvasFileInfo[];
   createdAt: string;
   hasFeedback: boolean;
   feedbackConsumed: boolean;
   response?: string;
-  diffStats?: DiffStats;
 }
 
 export interface SessionData {
   id: string;
   projectRoot: string;
-  jsx: string;
+  canvasFiles: string[];
   currentRevision: number;
   revisions: RevisionInfo[];
   createdAt: string;
@@ -36,7 +40,7 @@ interface SessionMeta {
   revisions: RevisionInfo[];
 }
 
-// Legacy format
+// Legacy format (flat files, pre-revision)
 interface LegacyMeta {
   projectRoot: string;
   createdAt: string;
@@ -44,6 +48,18 @@ interface LegacyMeta {
   version: number;
 }
 
+// Previous format (single sourceFile per revision)
+interface LegacyRevisionInfo {
+  revision: number;
+  label?: string;
+  sourceFile?: string;
+  createdAt: string;
+  hasFeedback: boolean;
+  feedbackConsumed: boolean;
+  response?: string;
+  diffStats?: DiffStats;
+}
+
 const STALE_TIMEOUT_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 function computeLineDiffStats(oldText: string, newText: string): DiffStats {
@@ -83,6 +99,32 @@ export class SessionManager {
     return join(this.sessionDir(id), "revisions", String(rev));
   }
 
+  /** Compute file order from revision history: first-appearance order, alpha for ties */
+  private deriveFileOrder(revisions: RevisionInfo[], currentFiles: string[]): string[] {
+    const seen = new Set<string>();
+    const ordered: string[] = [];
+    for (const rev of revisions) {
+      for (const cf of rev.canvasFiles) {
+        if (!seen.has(cf.filename)) {
+          seen.add(cf.filename);
+          ordered.push(cf.filename);
+        }
+      }
+    }
+    // Keep only files that still exist, then append any unknown ones
+    const current = new Set(currentFiles);
+    const result = ordered.filter(f => current.has(f));
+    const remaining = currentFiles.filter(f => !seen.has(f)).sort();
+    return [...result, ...remaining];
+  }
+
+  /** List *.jsx filenames in a revision directory */
+  getRevisionCanvasFiles(id: string, rev: number): string[] {
+    const dir = this.revisionDir(id, rev);
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir).filter(f => f.endsWith(".jsx")).sort();
+  }
+
   private loadFromDisk() {
     if (!existsSync(SESSIONS_DIR)) return;
     for (const name of readdirSync(SESSIONS_DIR, { withFileTypes: true })) {
@@ -94,17 +136,16 @@ export class SessionManager {
       try {
         const raw = JSON.parse(readFileSync(metaPath, "utf-8"));
 
-        // Detect and migrate legacy format
+        // Detect and migrate legacy flat-file format
         if ("version" in raw && !("currentRevision" in raw)) {
           this.migrateLegacy(name.name, raw as LegacyMeta);
-          // Re-read after migration
           const migrated: SessionMeta = JSON.parse(readFileSync(metaPath, "utf-8"));
-          const jsx = this.readRevisionJsx(name.name, migrated.currentRevision);
-          if (!jsx) continue;
+          const canvasFiles = this.getRevisionCanvasFiles(name.name, migrated.currentRevision);
+          if (canvasFiles.length === 0) continue;
           this.sessions.set(name.name, {
             id: name.name,
             projectRoot: migrated.projectRoot,
-            jsx,
+            canvasFiles,
             currentRevision: migrated.currentRevision,
             revisions: migrated.revisions,
             createdAt: migrated.createdAt,
@@ -113,14 +154,34 @@ export class SessionManager {
           continue;
         }
 
-        const meta = raw as SessionMeta;
-        const jsx = this.readRevisionJsx(name.name, meta.currentRevision);
-        if (!jsx) continue;
+        let meta = raw as SessionMeta;
+
+        // Migrate single-sourceFile revision format to canvasFiles
+        if (meta.revisions.length > 0 && !("canvasFiles" in meta.revisions[0])) {
+          meta = {
+            ...meta,
+            revisions: (meta.revisions as unknown as LegacyRevisionInfo[]).map(r => ({
+              revision: r.revision,
+              label: r.label,
+              canvasFiles: [{ filename: r.sourceFile || "plan.jsx", diffStats: r.diffStats }],
+              createdAt: r.createdAt,
+              hasFeedback: r.hasFeedback,
+              feedbackConsumed: r.feedbackConsumed,
+              response: r.response,
+            })),
+          };
+          writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+        }
+
+        const diskFiles = this.getRevisionCanvasFiles(name.name, meta.currentRevision);
+        if (diskFiles.length === 0) continue;
+        // Derive file order from revision history (first-appearance order)
+        const canvasFiles = this.deriveFileOrder(meta.revisions, diskFiles);
 
         this.sessions.set(name.name, {
           id: name.name,
           projectRoot: meta.projectRoot,
-          jsx,
+          canvasFiles,
           currentRevision: meta.currentRevision,
           revisions: meta.revisions,
           createdAt: meta.createdAt,
@@ -136,7 +197,6 @@ export class SessionManager {
     const flatCompiled = join(dir, "plan.compiled.js");
     const historyDir = join(dir, "history");
 
-    // Collect all historical revisions + current
     const revisions: RevisionInfo[] = [];
 
     // Migrate history files
@@ -148,7 +208,13 @@ export class SessionManager {
         const revDir = this.revisionDir(id, num);
         mkdirSync(revDir, { recursive: true });
         renameSync(join(historyDir, file), join(revDir, "plan.jsx"));
-        revisions.push({ revision: num, createdAt: legacy.createdAt, hasFeedback: false, feedbackConsumed: false });
+        revisions.push({
+          revision: num,
+          canvasFiles: [{ filename: "plan.jsx" }],
+          createdAt: legacy.createdAt,
+          hasFeedback: false,
+          feedbackConsumed: false,
+        });
       }
       rmSync(historyDir, { recursive: true, force: true });
     }
@@ -163,9 +229,14 @@ export class SessionManager {
     if (existsSync(flatCompiled)) {
       renameSync(flatCompiled, join(revDir, "plan.compiled.js"));
     }
-    revisions.push({ revision: currentRev, createdAt: legacy.updatedAt, hasFeedback: false, feedbackConsumed: false });
+    revisions.push({
+      revision: currentRev,
+      canvasFiles: [{ filename: "plan.jsx" }],
+      createdAt: legacy.updatedAt,
+      hasFeedback: false,
+      feedbackConsumed: false,
+    });
 
-    // Write new meta
     const meta: SessionMeta = {
       projectRoot: legacy.projectRoot,
       createdAt: legacy.createdAt,
@@ -176,37 +247,62 @@ export class SessionManager {
     writeFileSync(join(dir, "meta.json"), JSON.stringify(meta, null, 2));
   }
 
-  private readRevisionJsx(id: string, rev: number): string | null {
+  readRevisionJsx(id: string, rev: number, filename: string): string | null {
     try {
-      return readFileSync(join(this.revisionDir(id, rev), "plan.jsx"), "utf-8");
+      return readFileSync(join(this.revisionDir(id, rev), filename), "utf-8");
     } catch {
       return null;
     }
   }
 
-  upsert(id: string, jsx: string, projectRoot: string, label?: string, sourceFile?: string, response?: string): SessionData {
+  /**
+   * Create or update a session with a set of canvas files.
+   * @param canvasFiles Map of filename -> JSX content
+   */
+  upsert(id: string, canvasFiles: Map<string, string>, projectRoot: string, label?: string, response?: string): SessionData {
     const existing = this.sessions.get(id);
     const now = new Date().toISOString();
     const revision = existing ? existing.currentRevision + 1 : 1;
 
-    let diffStats: DiffStats | undefined;
-    if (existing && sourceFile) {
-      const prev = [...existing.revisions]
-        .reverse()
-        .find((r) => r.sourceFile === sourceFile);
-      if (prev) {
-        const prevJsx = this.readRevisionJsx(id, prev.revision);
-        if (prevJsx) diffStats = computeLineDiffStats(prevJsx, jsx);
+    // Compute per-file diffStats against the previous revision
+    const prevRev = existing ? existing.currentRevision : 0;
+    const canvasFileInfos: CanvasFileInfo[] = [];
+    for (const [filename, jsx] of canvasFiles) {
+      let diffStats: DiffStats | undefined;
+      if (prevRev > 0) {
+        const prevJsx = this.readRevisionJsx(id, prevRev, filename);
+        if (prevJsx) {
+          diffStats = computeLineDiffStats(prevJsx, jsx);
+        }
       }
+      canvasFileInfos.push({
+        filename,
+        ...(diffStats ? { diffStats } : {}),
+      });
     }
 
-    const revInfo: RevisionInfo = { revision, createdAt: now, hasFeedback: false, feedbackConsumed: false, ...(label ? { label } : {}), ...(sourceFile ? { sourceFile } : {}), ...(response ? { response } : {}), ...(diffStats ? { diffStats } : {}) };
+    const revInfo: RevisionInfo = {
+      revision,
+      canvasFiles: canvasFileInfos,
+      createdAt: now,
+      hasFeedback: false,
+      feedbackConsumed: false,
+      ...(label ? { label } : {}),
+      ...(response ? { response } : {}),
+    };
     const revisions = existing ? [...existing.revisions, revInfo] : [revInfo];
+    // Order: files from previous revision first (preserving their order), then new files alphabetically
+    const prevOrder = existing?.canvasFiles ?? [];
+    const currentNames = new Set(canvasFiles.keys());
+    const filenames = [
+      ...prevOrder.filter(f => currentNames.has(f)),
+      ...[...currentNames].filter(f => !prevOrder.includes(f)).sort(),
+    ];
 
     const session: SessionData = {
       id,
       projectRoot,
-      jsx,
+      canvasFiles: filenames,
       currentRevision: revision,
       revisions,
       createdAt: existing?.createdAt ?? now,
@@ -214,7 +310,7 @@ export class SessionManager {
     };
 
     this.sessions.set(id, session);
-    this.persistToDisk(session);
+    this.persistToDisk(session, canvasFiles);
     return session;
   }
 
@@ -229,10 +325,12 @@ export class SessionManager {
     writeFileSync(join(this.sessionDir(session.id), "meta.json"), JSON.stringify(meta, null, 2));
   }
 
-  private persistToDisk(session: SessionData) {
+  private persistToDisk(session: SessionData, canvasFiles: Map<string, string>) {
     const revDir = this.revisionDir(session.id, session.currentRevision);
     mkdirSync(revDir, { recursive: true });
-    writeFileSync(join(revDir, "plan.jsx"), session.jsx);
+    for (const [filename, jsx] of canvasFiles) {
+      writeFileSync(join(revDir, filename), jsx);
+    }
     this.persistMeta(session);
   }
 
@@ -249,21 +347,23 @@ export class SessionManager {
     rmSync(this.sessionDir(id), { recursive: true, force: true });
   }
 
-  saveCompiled(id: string, js: string, rev?: number) {
+  saveCompiled(id: string, filename: string, js: string, rev?: number) {
     const session = this.sessions.get(id);
     const revision = rev ?? session?.currentRevision;
     if (!revision) return;
     const revDir = this.revisionDir(id, revision);
     mkdirSync(revDir, { recursive: true });
-    writeFileSync(join(revDir, "plan.compiled.js"), js);
+    const compiledName = filename.replace(/\.jsx$/, ".compiled.js");
+    writeFileSync(join(revDir, compiledName), js);
   }
 
-  getCompiled(id: string, rev?: number): string | null {
+  getCompiled(id: string, filename: string, rev?: number): string | null {
     const session = this.sessions.get(id);
     const revision = rev ?? session?.currentRevision;
     if (!revision) return null;
+    const compiledName = filename.replace(/\.jsx$/, ".compiled.js");
     try {
-      return readFileSync(join(this.revisionDir(id, revision), "plan.compiled.js"), "utf-8");
+      return readFileSync(join(this.revisionDir(id, revision), compiledName), "utf-8");
     } catch {
       return null;
     }
@@ -305,7 +405,6 @@ export class SessionManager {
   getLatestUnconsumedFeedback(id: string): { revision: number; feedback: string } | null {
     const session = this.sessions.get(id);
     if (!session) return null;
-    // Search from newest to oldest
     for (let i = session.revisions.length - 1; i >= 0; i--) {
       const ri = session.revisions[i];
       if (ri.hasFeedback && !ri.feedbackConsumed) {
@@ -316,8 +415,8 @@ export class SessionManager {
     return null;
   }
 
-  getRevisionJsxPath(id: string, rev: number): string {
-    return join(this.revisionDir(id, rev), "plan.jsx");
+  getRevisionJsxPath(id: string, rev: number, filename: string): string {
+    return join(this.revisionDir(id, rev), filename);
   }
 
   cleanupStale(maxAge = STALE_TIMEOUT_MS) {