@lalalic/markcut 2.0.0 → 2.1.0

package/AGENTS.md

@@ -188,6 +188,7 @@ node src/render/cli.mjs templates
 - `--label` flag starts a labeling UI for selecting and annotating media
 - `--port` flag sets the server port (default 3001)
 - Unified server: `server.mjs` serves all modes (preview, edit, label). React control components in `components/`.
+- **Persistent AI agent via `pi --mode rpc`** (one cold start, many edits): at boot, `startAgentProcess()` spawns the configured agent CLI (`DEFAULT_AGENT_CLI`) with `--mode rpc` appended (the `-p/--prompt` flag is stripped — prompts arrive over stdin). Each `/api/edit` POST writes `{"id","type":"prompt","message"}` to stdin and resolves on the streamed `agent_settled` event (NOT idle-timeout guessing — pi's default interactive mode is a TUI, not a stdin REPL, so text/stdin mode does not work). Assistant text is collected from `message_end` events (`message.role==="assistant"`, text content blocks). `--session-id` (derived from the file path) resumes conversation history from disk across restarts. Do not revert to one-shot `spawn` per edit — that re-incurs the full cold-start every request.
 
 ## Testing
 

package/docs/system-prompt-edit.md

@@ -12,5 +12,8 @@ TASKS:
 1. Read the .md file directly using your file tools to see its current content
 2. Edit the .md file directly — change content, add/remove sections, update frontmatter
 3. Save the changes to the .md file using your write/edit tools
-4. Output ONLY a one-line summary of what specific change you made
-5. Do NOT output explanations, reasoning, or extra text
+4. Output ONLY a JSON object on a single line:
+   {"summary":"what specific change you made","fileChanged":true}
+   - `summary`: short description of the change
+   - `fileChanged`: true if you edited the file, false if no change was needed
+5. Do NOT output any other text, explanations, or reasoning — only the JSON line

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lalalic/markcut",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Markdown-to-video engine. Describe scenes in markdown, get a rendered video.",
   "bin": {
     "markcut": "bin/markcut"

package/src/player/bundle/player.js

@@ -60017,7 +60017,7 @@ function EditControls({ onStatusChange, suppressReloadRef, currentTime, activeSc
         });
         const data2 = await res.json();
         if (res.ok) {
-          const summary = (data2.output || "done").split("\n")[0].slice(0, 65);
+          const summary = data2.summary || (data2.output || "done").split("\n")[0].slice(0, 65);
           onStatusChange?.(summary);
           setTimeout(() => {
             if (suppressReloadRef) suppressReloadRef.current = false;
@@ -60348,15 +60348,6 @@ function LabelControls({ playerRef, currentTime, onSceneChange }) {
 // src/player/components/SceneThumbnails.tsx
 var React51 = __toESM(require_react(), 1);
 var import_jsx_runtime93 = __toESM(require_jsx_runtime(), 1);
-var VIDEO_EXT2 = {
-  ".mov": 1,
-  ".mp4": 1,
-  ".avi": 1,
-  ".mkv": 1,
-  ".webm": 1,
-  ".m4v": 1,
-  ".wmv": 1
-};
 function SceneThumbnails({ currentTime, onSeek }) {
   const [scenes, setScenes] = React51.useState([]);
   React51.useEffect(() => {
@@ -60375,22 +60366,12 @@ function SceneThumbnails({ currentTime, onSeek }) {
   }
   return /* @__PURE__ */ (0, import_jsx_runtime93.jsx)("div", { id: "scene-thumbnails", children: scenes.map((scene2, i3) => {
     const isActive = i3 === activeIdx;
-    const ext = scene2.src.substring(scene2.src.lastIndexOf(".")).toLowerCase();
-    const isVideo = !!VIDEO_EXT2[ext];
-    const hasMedia = !!scene2.src;
-    return /* @__PURE__ */ (0, import_jsx_runtime93.jsxs)(
-      "div",
+    return /* @__PURE__ */ (0, import_jsx_runtime93.jsx)(
+      "span",
       {
-        className: "sthumb-item" + (isActive ? " active" : ""),
+        className: "scene-pill" + (isActive ? " active" : ""),
         onClick: () => onSeek?.(scene2.start),
-        children: [
-          /* @__PURE__ */ (0, import_jsx_runtime93.jsxs)("div", { className: "sthumb-media", children: [
-            hasMedia && !isVideo && /* @__PURE__ */ (0, import_jsx_runtime93.jsx)("img", { src: scene2.src, alt: "", loading: "lazy" }),
-            hasMedia && isVideo && /* @__PURE__ */ (0, import_jsx_runtime93.jsx)("video", { src: scene2.src, muted: true, preload: "metadata" }),
-            !hasMedia && /* @__PURE__ */ (0, import_jsx_runtime93.jsx)("span", { className: "sthumb-fallback", children: (scene2.name || "S" + (i3 + 1)).slice(0, 2).toUpperCase() })
-          ] }),
-          /* @__PURE__ */ (0, import_jsx_runtime93.jsx)("span", { className: "sthumb-name", children: scene2.name || "Scene " + (i3 + 1) })
-        ]
+        children: scene2.name || "Scene " + (i3 + 1)
       },
       i3
     );

package/src/player/components/EditControls.tsx

@@ -40,7 +40,7 @@ export function EditControls({ onStatusChange, suppressReloadRef, currentTime, a
         });
         const data = await res.json();
         if (res.ok) {
-          const summary = (data.output || "done").split("\n")[0].slice(0, 65);
+          const summary = data.summary || (data.output || "done").split("\n")[0].slice(0, 65);
           onStatusChange?.(summary);
           setTimeout(() => {
             if (suppressReloadRef) suppressReloadRef.current = false;

package/src/player/components/SceneThumbnails.tsx

@@ -1,10 +1,8 @@
 /**
  * SceneThumbnails — horizontal scene selector for all modes.
  *
- * Fetches scene info from /api/video-info and renders clickable thumbnails
- * with scene names. Active scene is highlighted based on currentTime.
- *
- * Layout: supported in edit and preview modes (label mode has its own).
+ * Fetches scene info from /api/video-info and renders clickable scene name pills.
+ * Active scene is highlighted based on currentTime.
  */
 import * as React from "react";
 
@@ -12,15 +10,8 @@ interface Scene {
   name: string;
   start: number;
   end: number;
-  duration: number;
-  src: string;
-  mediaType: string;
 }
 
-const VIDEO_EXT: Record<string, number> = {
-  ".mov": 1, ".mp4": 1, ".avi": 1, ".mkv": 1, ".webm": 1, ".m4v": 1, ".wmv": 1,
-};
-
 interface SceneThumbnailsProps {
   /** Current player time in seconds — used to highlight active scene */
   currentTime: number;
@@ -42,7 +33,6 @@ export function SceneThumbnails({ currentTime, onSeek }: SceneThumbnailsProps) {
 
   if (scenes.length === 0) return null;
 
-  // Determine active scene index from currentTime
   let activeIdx = -1;
   for (let i = 0; i < scenes.length; i++) {
     if (currentTime >= scenes[i].start && currentTime < scenes[i].end) {
@@ -55,31 +45,14 @@ export function SceneThumbnails({ currentTime, onSeek }: SceneThumbnailsProps) {
     <div id="scene-thumbnails">
       {scenes.map((scene, i) => {
         const isActive = i === activeIdx;
-        const ext = scene.src.substring(scene.src.lastIndexOf(".")).toLowerCase();
-        const isVideo = !!VIDEO_EXT[ext];
-        const hasMedia = !!scene.src;
-
         return (
-          <div
+          <span
             key={i}
-            className={"sthumb-item" + (isActive ? " active" : "")}
+            className={"scene-pill" + (isActive ? " active" : "")}
             onClick={() => onSeek?.(scene.start)}
           >
-            <div className="sthumb-media">
-              {hasMedia && !isVideo && (
-                <img src={scene.src} alt="" loading="lazy" />
-              )}
-              {hasMedia && isVideo && (
-                <video src={scene.src} muted preload="metadata" />
-              )}
-              {!hasMedia && (
-                <span className="sthumb-fallback">
-                  {(scene.name || "S" + (i + 1)).slice(0, 2).toUpperCase()}
-                </span>
-              )}
-            </div>
-            <span className="sthumb-name">{scene.name || "Scene " + (i + 1)}</span>
-          </div>
+            {scene.name || "Scene " + (i + 1)}
+          </span>
         );
       })}
     </div>

package/src/player/server.mjs

@@ -78,6 +78,180 @@ let shutdownTimer = null;
 // ─── Label store for label mode ───────────────────────────────────────────
 let labels = [];
 
+// ─── Agent process (rpc mode) for --edit mode ─────────────────────────────
+// A persistent `pi --mode rpc` subprocess: ONE cold start, MANY edit turns.
+// The agent keeps conversation memory across edits (fast, no re-spawn).
+//
+// JSON-lines protocol over stdio:
+//   request:  {"id":N,"type":"prompt","message":"..."}
+//   response: {"id":N,"type":"response","command":"prompt","success":true}  (accepted)
+//   events:   streamed; a turn ENDS at {"type":"agent_settled"}
+// We collect assistant text from {"type":"message_end", message:{role:"assistant"}}
+// events and resolve the pending /api/edit call on agent_settled.
+let agentProcess = null;
+let agentBusy = false;
+let agentLineBuf = "";          // partial stdout line buffer
+let agentTurnText = "";         // accumulated assistant text for the current turn
+let agentTurnTimer = null;
+/** Resolve/reject for the pending edit API call */
+let pendingEditResolver = null;
+const AGENT_TURN_TIMEOUT = 300000; // 5min safety net per turn
+
+/** Pull text out of an assistant message_end event's content blocks. */
+function extractAssistantText(message) {
+  if (!message || message.role !== "assistant") return "";
+  const content = Array.isArray(message.content) ? message.content : [];
+  return content
+    .filter((b) => b && b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text)
+    .join("");
+}
+
+/** Resolve the pending edit call and reset per-turn state. */
+function finishAgentTurn(result) {
+  if (agentTurnTimer) { clearTimeout(agentTurnTimer); agentTurnTimer = null; }
+  agentBusy = false;
+  const turnText = agentTurnText;
+  agentTurnText = "";
+  const resolver = pendingEditResolver;
+  pendingEditResolver = null;
+  if (resolver) resolver({ ...result, output: result.output != null ? result.output : turnText });
+}
+
+/** Dispatch one parsed JSON line emitted on the agent's stdout. */
+function handleAgentLine(obj) {
+  if (!obj || typeof obj !== "object") return;
+  const t = obj.type;
+  if (t === "message_end") {
+    const txt = extractAssistantText(obj.message);
+    if (txt) agentTurnText += (agentTurnText ? "\n" : "") + txt;
+    return;
+  }
+  if (t === "agent_settled" && pendingEditResolver) {
+    finishAgentTurn({ ok: true });
+    return;
+  }
+  if (t === "response" && obj.command === "prompt" && pendingEditResolver) {
+    // Preflight result: success means "accepted, events incoming"; failure aborts.
+    if (obj.success === false) finishAgentTurn({ ok: false, error: obj.error || "prompt rejected" });
+    return;
+  }
+  if (t === "extension_error" && obj.error) {
+    console.warn(`  ⚠ agent extension error: ${String(obj.error).substring(0, 120)}`);
+  }
+}
+
+/**
+ * Start the persistent agent subprocess in rpc mode.
+ * The system prompt is fixed for the server lifetime (it only references the
+ * constant file path); per-edit context rides on each prompt's message.
+ */
+function startAgentProcess() {
+  if (!MODE_EDIT) return;
+
+  const agentCli = process.env.MARKCUT_AGENT_CLI || DEFAULT_AGENT_CLI;
+
+  const fileLabel = VIDEO_JSON.split("/").pop();
+  const sessionId = VIDEO_JSON.replace(/[^a-zA-Z0-9\-_.]/g, "_").replace(/^[^a-zA-Z0-9]+/, "").replace(/[^a-zA-Z0-9]+$/, "");
+  const promptTemplate = readFileSync(join(ROOT, "docs", "system-prompt-edit.md"), "utf-8");
+  const systemPrompt = promptTemplate
+    .replace(/@\{([^}]+)\}/g, (_, refPath) => {
+      try { return readFileSync(resolve(ROOT, refPath.trim()), "utf-8"); }
+      catch { console.warn(`  ⚠ could not read @{${refPath}}`); return `[Missing: ${refPath}]`; }
+    })
+    .replace(/\$\{fileName\}/g, fileLabel)
+    .replace(/\$\{filePath\}/g, VIDEO_JSON);
+
+  // Build the CLI command — strip -p/--prompt (rpc takes prompts via stdin) and
+  // force --mode rpc. e.g.
+  //   "npx pi --session-id {sessionid} --system-prompt {systemprompt} -p {prompt}"
+  //   → "npx pi --session-id SID --system-prompt SP --mode rpc"
+  const parts = agentCli.split(/\s+/).filter(Boolean);
+  const resolvedParts = [];
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    if (p === "-p" || p === "--prompt") { i++; continue; } // drop prompt flag + value
+    const resolved = p
+      .replace(/\{sessionid\}/g, sessionId)
+      .replace(/\{systemprompt\}/g, systemPrompt)
+      .replace(/\{prompt\}/g, "");
+    if (resolved) resolvedParts.push(resolved);
+  }
+  if (!resolvedParts.includes("--mode")) resolvedParts.push("--mode", "rpc");
+  const cmd = resolvedParts[0];
+  const cmdArgs = resolvedParts.slice(1);
+
+  console.log(`  🎬 starting persistent agent (rpc): ${cmd} ${cmdArgs.slice(0, -1).join(" ")} --system-prompt <${systemPrompt.length} chars>`);
+
+  const child = spawn(cmd, cmdArgs, { cwd: ROOT, stdio: ["pipe", "pipe", "pipe"] });
+  agentProcess = child;
+  agentLineBuf = "";
+
+  // stdout is pure JSON-lines in rpc mode (it takes over stdout). Parse line by line.
+  child.stdout.on("data", (chunk) => {
+    agentLineBuf += chunk.toString();
+    let nl;
+    while ((nl = agentLineBuf.indexOf("\n")) >= 0) {
+      const line = agentLineBuf.slice(0, nl).trim();
+      agentLineBuf = agentLineBuf.slice(nl + 1);
+      if (!line) continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch { continue; } // not JSON — ignore
+      handleAgentLine(obj);
+    }
+  });
+
+  child.stderr.on("data", (chunk) => { process.stderr.write(chunk); });
+
+  child.on("exit", (code) => {
+    console.log(`  ⚫ agent process exited (code ${code})`);
+    agentProcess = null;
+    if (pendingEditResolver) finishAgentTurn({ ok: false, error: `agent exited (code ${code})` });
+    agentBusy = false;
+    // Keep the session warm: restart on any exit while in edit mode.
+    // The --session-id resumes conversation history from disk.
+    if (MODE_EDIT) {
+      console.log(`  🔄 restarting agent in 1s...`);
+      setTimeout(() => startAgentProcess(), 1000);
+    }
+  });
+}
+
+/**
+ * Send an edit prompt to the persistent rpc agent and resolve when the turn
+ * settles. Completion is signalled authoritatively by the `agent_settled`
+ * event — no idle-timeout guessing.
+ * @param {string} prompt
+ * @returns {Promise<{ok: boolean, output: string, error?: string}>}
+ */
+function sendToAgent(prompt) {
+  return new Promise((resolve) => {
+    if (!agentProcess || agentProcess.killed) {
+      resolve({ ok: false, output: "", error: "agent process not running" });
+      return;
+    }
+    if (agentBusy) {
+      resolve({ ok: false, output: "", error: "agent is busy" });
+      return;
+    }
+
+    agentBusy = true;
+    agentTurnText = "";
+    pendingEditResolver = resolve;
+
+    // Safety net — the agent_settled event is the real completion signal.
+    agentTurnTimer = setTimeout(() => {
+      console.warn(`  ⏰ agent turn timed out after ${AGENT_TURN_TIMEOUT / 1000}s`);
+      finishAgentTurn({ ok: false, output: agentTurnText + "\n[TIMEOUT]", error: "agent turn timed out" });
+    }, AGENT_TURN_TIMEOUT);
+
+    const id = Date.now();
+    const req = JSON.stringify({ id, type: "prompt", message: prompt }) + "\n";
+    console.log(`  📤 rpc prompt (id=${id}): ${prompt.substring(0, 80).replace(/\n/g, " ")}`);
+    agentProcess.stdin.write(req);
+  });
+}
+
 // ─── Edit history for context ─────────────────────────────────────────────
 let editHistory = [];
 
@@ -618,13 +792,9 @@ function getHtml(variantLabel) {
   #scene-thumbnails { display: flex; gap: 6px; width: 100%; max-width: 500px; padding: 4px 12px; flex-shrink: 0; overflow-x: auto; scrollbar-width: thin; }
   #scene-thumbnails::-webkit-scrollbar { height: 4px; }
   #scene-thumbnails::-webkit-scrollbar-thumb { background: rgba(255,255,255,.15); border-radius: 2px; }
-  .sthumb-item { flex-shrink: 0; width: 72px; cursor: pointer; border-radius: 6px; overflow: hidden; border: 2px solid transparent; transition: all .15s; background: rgba(255,255,255,.05); display: flex; flex-direction: column; }
-  .sthumb-item:hover { border-color: rgba(74,158,255,.4); }
-  .sthumb-item.active { border-color: #4a9eff; box-shadow: 0 0 8px rgba(74,158,255,.3); }
-  .sthumb-media { width: 100%; height: 48px; overflow: hidden; position: relative; }
-  .sthumb-media img, .sthumb-media video { width: 100%; height: 100%; object-fit: cover; }
-  .sthumb-fallback { width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; background: rgba(255,255,255,.08); color: rgba(255,255,255,.3); font-size: 16px; font-weight: 600; }
-  .sthumb-name { font-size: 9px; color: rgba(255,255,255,.45); text-align: center; padding: 2px 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .scene-pill { flex-shrink: 0; padding: 4px 12px; border-radius: 12px; cursor: pointer; border: 1px solid transparent; transition: all .15s; background: rgba(255,255,255,.06); color: rgba(255,255,255,.45); font-size: 11px; white-space: nowrap; }
+  .scene-pill:hover { border-color: rgba(74,158,255,.4); color: rgba(255,255,255,.7); }
+  .scene-pill.active { background: rgba(74,158,255,.2); border-color: #4a9eff; color: #4a9eff; }
 </style>
 </head>
 <body>
@@ -759,145 +929,60 @@ const server = createServer(async (req, res) => {
       return;
     }
 
-    // API: Edit — call configured agent CLI to edit the .md source file
-    // Only supports markdown-descriptive (.md) files — the primary authoring format
-    // Uses DEFAULT_AGENT_CLI with {sessionid} replaced by sanitized file path for continuity
-    // System prompt: role "video director" + markcut skill + @{docs/markdown-descriptive.md}
-    // User prompt: current timestamp + active scene + edit request
+    // API: Edit — spawn agent CLI to edit the .md source file
+    // Uses the configured agent CLI (DEFAULT_AGENT_CLI) in one-shot mode.
+    // The agent receives the system prompt + edit request and outputs JSON.
     if (path === "/api/edit" && req.method === "POST") {
       let body = "";
       req.on("data", c => body += c);
-      req.on("end", () => {
+      req.on("end", async () => {
         try {
           const { text, currentTime, activeScene } = JSON.parse(body);
           if (!text) { res.writeHead(400); res.end(JSON.stringify({ error: "empty text" })); return; }
 
           editHistory.push(text);
 
-          // Read the current file content for the agent to edit
-          const rawContent = readFileSync(VIDEO_JSON, "utf-8");
-          const fileLabel = VIDEO_JSON.split("/").pop();
-          // Sanitize file path to a valid session ID (alphanumeric, -, _, .)
-          const sessionId = VIDEO_JSON.replace(/[^a-zA-Z0-9\-_.]/g, "_").replace(/^[^a-zA-Z0-9]+/, "").replace(/[^a-zA-Z0-9]+$/, "");
-
-          // Build tree structure description for context
-          let treeInfo = "";
-          try {
-            const parsed = JSON.parse(rawContent);
-            const root = parsed.root || parsed;
-
-            function describeNode(node, depth) {
-              const indent = "  ".repeat(depth);
-              const id = node.id || "";
-              const name = node.name || "";
-              const label = name || id;
-              const type = node.type || "unknown";
-              const dur = node.durationInSeconds !== undefined ? `, ${node.durationInSeconds}s` : "";
-              let line = `${indent}${type} "${label}"`;
-              if (type === "root") line += ` (${node.width}x${node.height}, ${node.fps}fps${node.isSeries ? ", series" : ""}${node.transition ? `, transition:${node.transition}` : ""}${node.theme ? `, theme:${node.theme}` : ""})`;
-              else if (type === "folder") line += ` (${node.isSeries ? "series" : "parallel"}${node.transition ? `, transition:${node.transition}` : ""}${dur})`;
-              else if (type === "component") {
-                const props = node.props ? JSON.stringify(Object.fromEntries(Object.entries(node.props).filter(([k]) => !k.startsWith("_")))) : "{}";
-                line += ` ${node.componentName}(${props.slice(0, 100)})${dur}`;
-              }
-              else if (type === "subtitle") { const txt = (node.src || "").slice(0, 60); line += ` "${txt}"${dur}`; }
-              else if (type === "video" || type === "audio" || type === "image") { const src = (node.src || "").slice(0, 50); line += ` "${src}"${dur}`; }
-              else if (type === "effect") line += ` animation:${node.animation || "custom"}${dur}`;
-              else if (type === "rhythm") line += ` src:"${(node.src || "").slice(0, 40)}"${dur}`;
-              else if (type === "map") line += ` waypoints:${(node.waypoints || []).length}${dur}`;
-              else if (type === "include") line += ` src:"${(node.src || "").slice(0, 50)}"${dur}`;
-              if (typeof node.start === "number" || typeof node.end === "number") {
-                const sStart = node.start ?? 0; const sEnd = node.end ?? sStart;
-                line += ` [${sStart}→${sEnd}s${node.isBackground ? ", bg" : ""}${node.volume !== undefined ? `, vol:${node.volume}` : ""}${node.loop ? `, loop:${node.loop}` : ""}]`;
-              } else if (node.isBackground) line += ` [bg]`;
-              const extras = [];
-              if (node.componentName) extras.push(node.componentName);
-              if (node.fit) extras.push(`fit:${node.fit}`);
-              if (node.fontSize) extras.push(`fontSize:${node.fontSize}`);
-              if (node.volume !== undefined && type !== "root") extras.push(`vol:${node.volume}`);
-              if (node.playbackRate) extras.push(`rate:${node.playbackRate}`);
-              if (node.transitionTime !== undefined) extras.push(`transTime:${node.transitionTime}`);
-              if (node.visible === false) extras.push("hidden");
-              if (extras.length > 0) line += ` {${extras.join(", ")}}`;
-              return line;
-            }
-            function walkTree(node, depth = 0) {
-              const lines = [describeNode(node, depth)];
-              if (node.children && node.children.length > 0) {
-                for (const child of node.children.filter(c => c.visible !== false || c.visible === undefined)) lines.push(...walkTree(child, depth + 1));
-              }
-              return lines;
-            }
-            treeInfo = walkTree(root).join("\n");
-          } catch {}
-
-          const historyStr = editHistory.length > 1
-            ? "Previous edits (in order):\n" + editHistory.slice(0, -1).map((e, i) => `${i+1}. ${e}`).join("\n") + "\n"
-            : "";
-
-          // Build system prompt from template file (resolves @{path} references)
-          // System prompt is stable — it contains the role, skills, and format docs.
-          // Tree info and history change per-edit, so they go in the user prompt.
-          const promptTemplate = readFileSync(join(ROOT, "docs", "system-prompt-edit.md"), "utf-8");
-          const systemPrompt = promptTemplate
-            .replace(/@\{([^}]+)\}/g, (_, refPath) => {
-              try {
-                return readFileSync(resolve(ROOT, refPath.trim()), "utf-8");
-              } catch {
-                console.warn(`  ⚠ could not read @{${refPath}}`);
-                return `[Missing: ${refPath}]`;
-              }
-            })
-            .replace(/\$\{fileName\}/g, fileLabel)
-            .replace(/\$\{filePath\}/g, VIDEO_JSON);
-
-          // Build user prompt with current context (changes every edit)
+          // Build user prompt with context (system prompt is fixed at agent startup)
           const timeStr = currentTime !== undefined ? `Current playback time: ${Number(currentTime).toFixed(1)}s` : "";
           const sceneStr = activeScene ? `Active scene: ${activeScene}` : "";
           const contextBlock = [timeStr, sceneStr].filter(Boolean).join("\n");
-
-          const userPrompt = `--- Current stream tree (for reference) ---
-${treeInfo || "(compiled tree)"}
+          const historyStr = editHistory.length > 1
+            ? "Previous edits (in order):\n" + editHistory.slice(0, -1).map((e, i) => `${i+1}. ${e}`).join("\n") + "\n"
+            : "";
+          const userPrompt = `${contextBlock}
 ${historyStr}
-${contextBlock}
 Edit request: ${text}`;
 
-          // Resolve agent CLI template with all placeholders
-          // Each placeholder is its own argument in the template (no shell quotes needed)
-          const agentCli = process.env.MARKCUT_AGENT_CLI || DEFAULT_AGENT_CLI;
-          const parts = agentCli.split(/\s+/);
-          const resolvedParts = parts.map(p =>
-            p.replace(/\{sessionid\}/g, sessionId)
-             .replace(/\{systemprompt\}/g, systemPrompt)
-             .replace(/\{prompt\}/g, userPrompt)
-          );
-          const cmd = resolvedParts[0];
-          const cmdArgs = resolvedParts.slice(1);
-
           console.log(`  🤖 edit: ${text}  (${currentTime !== undefined ? currentTime.toFixed(1) + "s" : ""} ${activeScene || ""})`);
-          console.log(`  🎬 session: ${sessionId}`);
-          console.log(`  📋 cmd: ${agentCli.split(/\s+/)[0]} ${agentCli.split(/\s+/).slice(1).join(" ").replace(/\{prompt\}/g, "...").substring(0, 120)}`);
-
-          const child = spawn(cmd, cmdArgs, {
-            cwd: ROOT,
-            stdio: ["ignore", "pipe", "pipe"],
-          });
-
-          let output = "";
-          child.stdout.on("data", d => output += d);
-          child.stderr.on("data", d => output += d);
-
-          child.on("exit", (code) => {
-            if (code === 0) {
-              console.log(`  ✅ edit complete`);
-              res.writeHead(200, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ done: true, output: output.trim() }));
+
+          // Send to the persistent rpc agent (one cold start; conversation kept in memory)
+          const result = await sendToAgent(userPrompt);
+
+          if (result.ok) {
+            // Parse JSON summary from the agent's final assistant text
+            let summary = "";
+            let fileChanged = false;
+            const raw = (result.output || "").trim();
+            const jsonMatch = raw.match(/\{[\s\S]*"summary"[\s\S]*\}/);
+            if (jsonMatch) {
+              try {
+                const parsed = JSON.parse(jsonMatch[0]);
+                summary = parsed.summary || raw.substring(0, 120);
+                fileChanged = parsed.fileChanged === true;
+              } catch { summary = raw.substring(0, 120); }
             } else {
-              console.error(`  ❌ edit failed (exit ${code}): ${output.trim()}`);
-              res.writeHead(500, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ error: `agent exited with code ${code}`, output: output.trim() }));
+              summary = raw.substring(0, 120) || "done";
             }
-          });
+            console.log(`  ✅ ${fileChanged ? "edited" : "no change"}: ${summary}`);
+            console.log(`  📤 response summary="${summary}" fileChanged=${fileChanged}`);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ done: true, summary, fileChanged, output: "" }));
+          } else {
+            const msg = result.error || "failed";
+            console.error(`  ❌ edit ${msg}: ${(result.output || "").trim().substring(0, 100)}`);
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: msg, output: (result.output || "").trim().substring(0, 200) }));
+          }
         } catch (e) {
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: e.message }));
@@ -1000,6 +1085,11 @@ server.listen(PORT, async () => {
     // Pipeline failed — still announce ready so the player can show an error state
   }
 
+  // Start persistent agent process for edit mode (after initial compilation)
+  if (MODE_EDIT) {
+    startAgentProcess();
+  }
+
   const mode = MODE_LABEL ? " --label" : MODE_EDIT ? " --edit" : "";
   console.log(`\n🎬 Player ready at http://localhost:${PORT}${mode}`);
   if (VARIANT_CONFIGS.length > 1) {