svamp-cli 0.2.114 → 0.2.115

package/dist/{run-aNUfTpRW.mjs → run-DXzaCfex.mjs}

@@ -1,7 +1,7 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import os$1, { homedir as homedir$1 } from 'os';
 import fs, { mkdir as mkdir$1, readdir as readdir$1, readFile, writeFile as writeFile$1, rename, unlink } from 'fs/promises';
-import { readFileSync as readFileSync$1, mkdirSync as mkdirSync$1, writeFileSync as writeFileSync$1, renameSync as renameSync$1, existsSync as existsSync$1, rmSync as rmSync$1, unlinkSync as unlinkSync$1, copyFileSync, readdirSync as readdirSync$1, watch, rmdirSync } from 'fs';
-import path__default, { join as join$1, dirname as dirname$1, basename as basename$1, resolve } from 'path';
+import { readFileSync as readFileSync$1, mkdirSync as mkdirSync$1, writeFileSync as writeFileSync$1, renameSync as renameSync$1, existsSync as existsSync$1, realpathSync, rmSync as rmSync$1, copyFileSync, unlinkSync as unlinkSync$1, readdirSync as readdirSync$1, watch, rmdirSync } from 'fs';
+import path__default, { join as join$1, resolve, dirname as dirname$1, basename as basename$1 } from 'path';
 import { fileURLToPath } from 'url';
 import { execFile, spawn as spawn$1, execSync as execSync$1, spawnSync } from 'child_process';
 import { randomUUID as randomUUID$1 } from 'crypto';
@@ -2676,7 +2676,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const tunnels = handlers.tunnels;
         if (!tunnels) throw new Error("Tunnel management not available");
         if (tunnels.has(params.name)) throw new Error(`Tunnel '${params.name}' already running`);
-        const { FrpcTunnel } = await import('./frpc-BjWZ129L.mjs');
+        const { FrpcTunnel } = await import('./frpc-1aSnPVrE.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -2937,7 +2937,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
           }
           const deps = buildSessionDeps(rpc, { cwd, ownerEmail: owner });
           const sender = { name: context?.user?.email || context?.user?.id || "user", kind: "user", verified: true };
-          const { toolsForRole } = await import('./sideband-BCKpph51.mjs');
+          const { toolsForRole } = await import('./sideband-vimBRRDF.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3036,7 +3036,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
     if (r.error || !r.sender) return { error: r.error || "unauthorized" };
     const callId = "call_" + Math.random().toString(16).slice(2, 12);
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-C29ciVUe.mjs');
+    const { queryCore } = await import('./commands-B3NhziMR.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3479,6 +3479,48 @@ function appendMessage(messagesDir, sessionId, msg) {
     console.error(`[HYPHA SESSION ${sessionId}] Failed to persist message: ${err?.message ?? err}`);
   }
 }
+function editableInfo(msg) {
+  const c = msg?.content;
+  if (!c) return null;
+  if (c.role === "user" && c.content?.type === "text") {
+    return { role: "user", text: String(c.content.text ?? "") };
+  }
+  if (c.role === "agent" && c.content?.type === "output") {
+    const data = c.content.data;
+    if (data?.type === "assistant" && Array.isArray(data?.message?.content)) {
+      const textBlocks = data.message.content.filter((b) => b && b.type === "text" && typeof b.text === "string");
+      if (textBlocks.length >= 1) {
+        return { role: "assistant", text: textBlocks.map((b) => b.text).join("\n") };
+      }
+    }
+    if (data?.type === "user" && typeof data?.message?.content === "string") {
+      return { role: "user", text: data.message.content };
+    }
+  }
+  return null;
+}
+function patchStoredText(msg, newText) {
+  const c = msg?.content;
+  if (c?.role === "user" && c.content?.type === "text") {
+    c.content.text = newText;
+    return true;
+  }
+  if (c?.role === "agent" && c.content?.type === "output") {
+    const data = c.content.data;
+    if (data?.type === "user" && typeof data?.message?.content === "string") {
+      data.message.content = newText;
+      return true;
+    }
+    if (data?.type === "assistant" && Array.isArray(data?.message?.content)) {
+      const textBlocks = data.message.content.filter((b) => b && b.type === "text" && typeof b.text === "string");
+      if (textBlocks.length === 1) {
+        textBlocks[0].text = newText;
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function createSessionStore(server, sessionId, initialMetadata, initialAgentState, callbacks, options) {
   const messages = options?.messagesDir ? loadMessages(options.messagesDir) : [];
   let nextSeq = messages.length > 0 ? messages[messages.length - 1].seq + 1 : 1;
@@ -3624,6 +3666,100 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     notifyListeners({ type: "update-session", sessionId, metadata: { value: metadata, version: metadataVersion } });
     callbacks.onMetadataUpdate?.(metadata);
   };
+  const forkClaudePrint = async (prompt, claudeSessionId, cwd, maxTurns = 6) => {
+    const { spawn } = await import('child_process');
+    return new Promise((resolve) => {
+      const child = spawn("claude", [
+        "--print",
+        prompt,
+        "--resume",
+        claudeSessionId,
+        "--fork-session",
+        "--no-session-persistence",
+        "--permission-mode",
+        "bypassPermissions",
+        "--output-format",
+        "json",
+        "--max-turns",
+        String(maxTurns)
+      ], {
+        cwd,
+        timeout: 6e4,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1" }
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (d) => {
+        stdout += d.toString();
+      });
+      child.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      child.on("close", (code) => {
+        if (code !== 0 && !stdout) {
+          resolve({ success: false, error: stderr || `claude exited with code ${code}` });
+          return;
+        }
+        try {
+          const result = JSON.parse(stdout);
+          resolve({ success: true, text: result.result || result.text || stdout });
+        } catch {
+          resolve({ success: true, text: stdout.trim() });
+        }
+      });
+      child.on("error", (err) => resolve({ success: false, error: err.message }));
+    });
+  };
+  const performEdit = async (target, newText) => {
+    if (!callbacks.onEditTranscript) return { success: false, message: "Editing history is not supported for this session." };
+    const info = editableInfo(target);
+    if (!info) return { success: false, message: "This message cannot be edited." };
+    const text = typeof newText === "string" ? newText : "";
+    if (!text.trim()) return { success: false, message: "New text is empty." };
+    let fromEnd = 0;
+    for (const m of messages) {
+      if (m.seq <= target.seq) continue;
+      const i2 = editableInfo(m);
+      if (i2 && i2.role === info.role) fromEnd++;
+    }
+    const anchorSeq = target.seq;
+    const applyStoreA = () => {
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].seq > anchorSeq) messages.splice(i, 1);
+      }
+      const tgt = messages.find((m) => m.seq === anchorSeq);
+      if (tgt) {
+        patchStoredText(tgt, text);
+        tgt.updatedAt = Date.now();
+      }
+      nextSeq = anchorSeq + 1;
+      if (options?.messagesDir) {
+        const filePath = join(options.messagesDir, "messages.jsonl");
+        try {
+          const lines = existsSync(filePath) ? readFileSync(filePath, "utf-8").split("\n").filter((l) => l.trim()) : [];
+          const kept = [];
+          for (const line of lines) {
+            let m;
+            try {
+              m = JSON.parse(line);
+            } catch {
+              continue;
+            }
+            if (typeof m.seq === "number" && m.seq > anchorSeq) continue;
+            kept.push(m.seq === anchorSeq && tgt ? JSON.stringify(tgt) : line);
+          }
+          const tmp = `${filePath}.tmp-${process.pid}`;
+          writeFileSync(tmp, kept.length ? kept.join("\n") + "\n" : "");
+          renameSync(tmp, filePath);
+        } catch (err) {
+          console.error(`[HYPHA SESSION ${sessionId}] Store A rewrite failed: ${err?.message ?? err}`);
+        }
+      }
+      notifyListeners({ type: "messages-edited", sessionId, latestSeq: nextSeq - 1 });
+    };
+    return callbacks.onEditTranscript({ role: info.role, fromEnd, oldText: info.text, newText: text, applyStoreA });
+  };
   const rpcHandlers = {
     // ── Messages ──
     getMessages: async (afterSeq, limit, context) => {
@@ -4303,59 +4439,72 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       if (!claudeSessionId) {
         return { success: false, error: "No active Claude session to query" };
       }
-      const { spawn } = await import('child_process');
-      const cwd = metadata.path || process.cwd();
-      return new Promise((resolve) => {
-        const args = [
-          "--print",
-          question,
-          "--resume",
-          claudeSessionId,
-          "--fork-session",
-          "--no-session-persistence",
-          "--permission-mode",
-          "bypassPermissions",
-          "--output-format",
-          "json",
-          // Allow a few turns so questions that need a look-up (read a file,
-          // check state) can make the tool call AND then answer. With 1 turn,
-          // any tool-using question died instantly with error_max_turns
-          // ("couldn't answer quickly"). The 60s subprocess timeout still bounds it.
-          "--max-turns",
-          "6"
-        ];
-        const child = spawn("claude", args, {
-          cwd,
-          timeout: 6e4,
-          // Ignore stdin: --print otherwise waits ~3s for piped input ("no stdin
-          // data received in 3s, proceeding without it") — pure latency per /btw.
-          stdio: ["ignore", "pipe", "pipe"],
-          env: { ...process.env, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1" }
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout?.on("data", (d) => {
-          stdout += d.toString();
-        });
-        child.stderr?.on("data", (d) => {
-          stderr += d.toString();
-        });
-        child.on("close", (code) => {
-          if (code !== 0 && !stdout) {
-            resolve({ success: false, error: stderr || `claude exited with code ${code}` });
-            return;
-          }
-          try {
-            const result = JSON.parse(stdout);
-            resolve({ success: true, answer: result.result || result.text || stdout });
-          } catch {
-            resolve({ success: true, answer: stdout.trim() });
-          }
-        });
-        child.on("error", (err) => {
-          resolve({ success: false, error: err.message });
-        });
-      });
+      const r = await forkClaudePrint(question, claudeSessionId, metadata.path || process.cwd());
+      return r.success ? { success: true, answer: r.text } : { success: false, error: r.error };
+    },
+    editMessage: async (messageId, newText, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!messageId) return { success: false, message: "messageId is required." };
+      const target = messages.find((m) => m.id === messageId);
+      if (!target) {
+        return { success: false, message: "Message not found in the active window \u2014 only recent messages can be edited." };
+      }
+      return performEdit(target, newText);
+    },
+    refineLastReply: async (instruction, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!instruction || typeof instruction !== "string") {
+        return { success: false, message: "An instruction is required." };
+      }
+      const claudeSessionId = metadata.claudeSessionId;
+      if (!claudeSessionId) return { success: false, message: "No active Claude session to refine." };
+      let last;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const info = editableInfo(messages[i]);
+        if (info && info.role === "assistant") {
+          last = messages[i];
+          break;
+        }
+      }
+      if (!last) return { success: false, message: "No assistant reply to refine." };
+      const oldText = editableInfo(last).text;
+      const prompt = `You previously wrote this reply:
+
+<previous_reply>
+${oldText}
+</previous_reply>
+
+Revise it according to this instruction:
+<instruction>
+${instruction}
+</instruction>
+
+Output ONLY the full revised reply text \u2014 no preamble, no commentary, no surrounding quotes or code fences.`;
+      const revised = await forkClaudePrint(prompt, claudeSessionId, metadata.path || process.cwd());
+      if (!revised.success || !revised.text?.trim()) {
+        return { success: false, message: revised.error || "Failed to generate a revised reply." };
+      }
+      return performEdit(last, revised.text.trim());
+    },
+    undoLastEdit: async (context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onUndoEdit) return { success: false, message: "Undo is not supported for this session." };
+      const restoreStoreA = () => {
+        if (!options?.messagesDir) return;
+        try {
+          const undoBackup = join(options.messagesDir, "undo", "messages.jsonl");
+          const target = join(options.messagesDir, "messages.jsonl");
+          if (existsSync(undoBackup)) writeFileSync(target, readFileSync(undoBackup));
+          const reloaded = loadMessages(options.messagesDir, sessionId);
+          messages.length = 0;
+          messages.push(...reloaded);
+          nextSeq = messages.length ? messages[messages.length - 1].seq + 1 : 1;
+          notifyListeners({ type: "messages-edited", sessionId, latestSeq: nextSeq - 1 });
+        } catch (err) {
+          console.error(`[HYPHA SESSION ${sessionId}] Undo Store A restore failed: ${err?.message ?? err}`);
+        }
+      };
+      return callbacks.onUndoEdit({ restoreStoreA });
     }
   };
   const store = {
@@ -7189,6 +7338,171 @@ var GeminiTransport$1 = /*#__PURE__*/Object.freeze({
     GeminiTransport: GeminiTransport
 });
 
+function resolveTranscriptPath(cwd, claudeSessionId) {
+  let real;
+  try {
+    real = realpathSync(cwd);
+  } catch {
+    real = resolve(cwd);
+  }
+  const projectId = real.replace(/[^a-zA-Z0-9-]/g, "-");
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join$1(os$1.homedir(), ".claude");
+  return join$1(claudeConfigDir, "projects", projectId, `${claudeSessionId}.jsonl`);
+}
+function normalizeText(t) {
+  return (t || "").replace(/\s+/g, " ").trim();
+}
+function parseTranscript(file) {
+  const content = readFileSync$1(file, "utf-8");
+  return content.split("\n").filter((l) => l.trim().length > 0).map((raw) => {
+    let obj = null;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+    }
+    return { raw, obj };
+  });
+}
+function assistantText(obj) {
+  const content = obj?.message?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((b) => b && b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
+}
+function isRealUserRecord(obj) {
+  return !!obj && obj.type === "user" && !obj.isSidechain && typeof obj?.message?.content === "string";
+}
+function isAgentTextRecord(obj) {
+  if (!obj || obj.type !== "assistant" || obj.isSidechain) return false;
+  const content = obj?.message?.content;
+  if (!Array.isArray(content)) return false;
+  return content.some((b) => b && b.type === "text" && typeof b.text === "string");
+}
+function isRoleTextRecord(obj, role) {
+  return role === "user" ? isRealUserRecord(obj) : isAgentTextRecord(obj);
+}
+function recordText(obj, role) {
+  return role === "user" ? String(obj?.message?.content ?? "") : assistantText(obj);
+}
+function findAnchorIndex(lines, anchor) {
+  const roleIdx = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (isRoleTextRecord(lines[i].obj, anchor.role)) roleIdx.push(i);
+  }
+  if (roleIdx.length === 0) {
+    return { ok: false, reason: `no ${anchor.role} text records in transcript` };
+  }
+  const pos = roleIdx.length - 1 - anchor.fromEnd;
+  if (pos < 0 || pos >= roleIdx.length) {
+    return { ok: false, reason: `anchor position out of range (fromEnd=${anchor.fromEnd}, have ${roleIdx.length})` };
+  }
+  const index = roleIdx[pos];
+  const got = normalizeText(recordText(lines[index].obj, anchor.role));
+  const want = normalizeText(anchor.oldText);
+  if (got !== want) {
+    if (!(want.length > 0 && got.startsWith(want))) {
+      return { ok: false, reason: "anchor text mismatch \u2014 stores out of sync, refusing to edit" };
+    }
+  }
+  return { ok: true, index };
+}
+function orphanCheckObjs(objs) {
+  const toolUseIds = /* @__PURE__ */ new Set();
+  const toolResultIds = /* @__PURE__ */ new Set();
+  for (const obj of objs) {
+    const content = obj?.message?.content;
+    if (!Array.isArray(content)) continue;
+    for (const b of content) {
+      if (b?.type === "tool_use" && b.id) toolUseIds.add(b.id);
+      if (b?.type === "tool_result" && b.tool_use_id) toolResultIds.add(b.tool_use_id);
+    }
+  }
+  for (const id of toolUseIds) {
+    if (!toolResultIds.has(id)) return true;
+  }
+  return false;
+}
+function applyTranscriptEdit(file, index, newText) {
+  if (!existsSync$1(file)) return { ok: false, reason: `transcript not found: ${file}` };
+  const lines = parseTranscript(file);
+  if (index < 0 || index >= lines.length) return { ok: false, reason: "index out of range" };
+  const target = lines[index].obj;
+  if (!target) return { ok: false, reason: "target line not parseable" };
+  if (target.type === "assistant") {
+    const content = target?.message?.content;
+    if (!Array.isArray(content)) return { ok: false, reason: "assistant content is not a block array" };
+    const textBlocks = content.filter((b) => b && b.type === "text" && typeof b.text === "string");
+    if (textBlocks.length !== 1) {
+      return { ok: false, reason: `expected exactly 1 text block, found ${textBlocks.length}` };
+    }
+    textBlocks[0].text = newText;
+  } else if (target.type === "user") {
+    if (typeof target?.message?.content !== "string") {
+      return { ok: false, reason: "user content is not a string" };
+    }
+    target.message.content = newText;
+  } else {
+    return { ok: false, reason: `unsupported record type: ${target.type}` };
+  }
+  const keptObjs = [];
+  const kept = [];
+  for (let i = 0; i <= index; i++) {
+    kept.push(i === index ? JSON.stringify(target) : lines[i].raw);
+    keptObjs.push(lines[i].obj);
+  }
+  if (orphanCheckObjs(keptObjs)) {
+    return { ok: false, reason: "edit would orphan a tool_use (truncation drops its tool_result)" };
+  }
+  const out = kept.join("\n") + "\n";
+  const tmp = `${file}.tmp-${process.pid}`;
+  try {
+    writeFileSync$1(tmp, out);
+    renameSync$1(tmp, file);
+  } catch (err) {
+    return { ok: false, reason: `write failed: ${err?.message ?? err}` };
+  }
+  return { ok: true, truncatedAfter: index, totalBefore: lines.length };
+}
+function saveUndoSnapshot(undoDir, transcriptFile, messagesFile, meta) {
+  mkdirSync$1(undoDir, { recursive: true });
+  if (existsSync$1(transcriptFile)) copyFileSync(transcriptFile, join$1(undoDir, "transcript.jsonl"));
+  if (existsSync$1(messagesFile)) copyFileSync(messagesFile, join$1(undoDir, "messages.jsonl"));
+  writeFileSync$1(join$1(undoDir, "meta.json"), JSON.stringify(meta));
+}
+function readUndoMeta(undoDir) {
+  const p = join$1(undoDir, "meta.json");
+  if (!existsSync$1(p)) return null;
+  try {
+    return JSON.parse(readFileSync$1(p, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function restoreTranscriptFromUndo(undoDir, targetFile) {
+  const backup = join$1(undoDir, "transcript.jsonl");
+  if (!existsSync$1(backup)) return false;
+  const tmp = `${targetFile}.tmp-${process.pid}`;
+  writeFileSync$1(tmp, readFileSync$1(backup));
+  renameSync$1(tmp, targetFile);
+  return true;
+}
+function clearUndoSnapshot(undoDir) {
+  try {
+    rmSync$1(undoDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function transcriptSessionIdMatches(file, expectedSessionId) {
+  if (!existsSync$1(file)) return false;
+  const lines = parseTranscript(file);
+  for (const { obj } of lines) {
+    if (obj && typeof obj.sessionId === "string") {
+      return obj.sessionId === expectedSessionId;
+    }
+  }
+  return false;
+}
+
 const execFileAsync = promisify$1(execFile$1);
 const SVAMP_TOOLS_DIR = join(homedir(), ".svamp", "tools");
 const SVAMP_BIN_DIR = join(SVAMP_TOOLS_DIR, "bin");
@@ -10491,7 +10805,7 @@ async function startDaemon(options) {
     const list = loadExposedTunnels().filter((t) => t.name !== name);
     saveExposedTunnels(list);
   }
-  const { ServeManager } = await import('./serveManager-DrPFeC2o.mjs');
+  const { ServeManager } = await import('./serveManager-BnwAe-VX.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -11543,12 +11857,13 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           }
           return child;
         };
-        const restartClaudeHandler = async () => {
+        const restartClaudeHandler = async (opts) => {
           logger.log(`[Session ${sessionId}] Restart Claude requested`);
           if (isRestartingClaude || isSwitchingMode) {
             return { success: false, message: "Restart already in progress." };
           }
           isRestartingClaude = true;
+          let beforeRespawnError;
           try {
             if (claudeProcess && claudeProcess.exitCode === null) {
               isKillingClaude = true;
@@ -11560,6 +11875,14 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             if (trackedSession?.stopped) {
               return { success: false, message: "Session was stopped during restart." };
             }
+            if (opts?.beforeRespawn) {
+              try {
+                await opts.beforeRespawn();
+              } catch (hookErr) {
+                beforeRespawnError = hookErr?.message ?? String(hookErr);
+                logger.log(`[Session ${sessionId}] beforeRespawn hook failed: ${beforeRespawnError}`);
+              }
+            }
             if (claudeResumeId) {
               if (!stagedCredentials && shouldIsolateSession()) {
                 try {
@@ -11572,6 +11895,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               spawnClaude(void 0, { permissionMode: currentPermissionMode });
               sessionService.updateMetadata(sessionMetadata);
               logger.log(`[Session ${sessionId}] Claude respawned with --resume ${claudeResumeId}`);
+              if (beforeRespawnError) {
+                return { success: false, message: `Edit failed (session restored): ${beforeRespawnError}` };
+              }
               return { success: true, message: "Claude process restarted successfully." };
             } else {
               logger.log(`[Session ${sessionId}] No resume ID \u2014 cannot restart`);
@@ -11585,6 +11911,26 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             isRestartingClaude = false;
           }
         };
+        const editHistoryIdleGuard = () => {
+          const lifecycle = sessionMetadata.lifecycleState;
+          if (lifecycle === "running" || lifecycle === "restarting") {
+            return { success: false, message: "Cannot edit while the agent is working \u2014 wait until it is idle." };
+          }
+          if (isRestartingClaude || isSwitchingMode || isKillingClaude) {
+            return { success: false, message: "Cannot edit during a restart/mode switch \u2014 try again in a moment." };
+          }
+          const queueLen = sessionMetadata.messageQueue?.length ?? 0;
+          if (queueLen > 0) {
+            return { success: false, message: "Cannot edit while messages are queued." };
+          }
+          if (isLoopActiveForSession(directory, sessionId)) {
+            return { success: false, message: "Cannot edit history while a loop is active." };
+          }
+          if (!claudeResumeId) {
+            return { success: false, message: "No Claude transcript to edit yet." };
+          }
+          return null;
+        };
         if (shouldIsolateSession()) {
           try {
             stagedCredentials = await stageCredentialsForSharing(sessionId);
@@ -11605,6 +11951,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               logger.log(`[Session ${sessionId}] User message received`);
               userMessagePending = true;
               turnInitiatedByUser = true;
+              clearUndoSnapshot(join$1(getSessionDir(directory, sessionId), "undo"));
               let text;
               let msgMeta = meta;
               try {
@@ -11824,6 +12171,86 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               }
             },
             onRestartClaude: restartClaudeHandler,
+            onEditTranscript: async ({ role, fromEnd, oldText, newText, applyStoreA }) => {
+              const gate = editHistoryIdleGuard();
+              if (gate) return gate;
+              logger.log(`[Session ${sessionId}] Edit history: role=${role} fromEnd=${fromEnd} \u2192 kill + rewrite + resume`);
+              const result = await restartClaudeHandler({
+                beforeRespawn: async () => {
+                  const file = resolveTranscriptPath(directory, claudeResumeId);
+                  if (!transcriptSessionIdMatches(file, claudeResumeId)) {
+                    throw new Error("transcript file id mismatch (session rotated) \u2014 aborting edit");
+                  }
+                  const lines = parseTranscript(file);
+                  const anchor = findAnchorIndex(lines, { role, fromEnd, oldText });
+                  if (!anchor.ok) throw new Error(anchor.reason);
+                  const sessDir = getSessionDir(directory, sessionId);
+                  saveUndoSnapshot(join$1(sessDir, "undo"), file, join$1(sessDir, "messages.jsonl"), {
+                    preEditClaudeSessionId: claudeResumeId,
+                    createdAt: Date.now(),
+                    label: "edit"
+                  });
+                  const edit = applyTranscriptEdit(file, anchor.index, newText);
+                  if (!edit.ok) throw new Error(edit.reason);
+                  applyStoreA();
+                  logger.log(`[Session ${sessionId}] Edit applied \u2014 transcript truncated after line ${anchor.index}`);
+                }
+              });
+              if (result.success && claudeResumeId && !trackedSession.stopped) {
+                saveSession({
+                  sessionId,
+                  directory,
+                  claudeResumeId,
+                  permissionMode: currentPermissionMode,
+                  spawnMeta: lastSpawnMeta,
+                  metadata: sessionMetadata,
+                  createdAt: sessionCreatedAt,
+                  machineId,
+                  wasProcessing: false
+                });
+                artifactSync.syncSession(sessionId, getSessionDir(directory, sessionId), sessionMetadata, machineId).catch(() => {
+                });
+              }
+              return result;
+            },
+            onUndoEdit: async ({ restoreStoreA }) => {
+              const gate = editHistoryIdleGuard();
+              if (gate) return gate;
+              const undoDir = join$1(getSessionDir(directory, sessionId), "undo");
+              const meta = readUndoMeta(undoDir);
+              if (!meta) return { success: false, message: "Nothing to undo." };
+              logger.log(`[Session ${sessionId}] Undo edit \u2192 restore pre-edit transcript ${meta.preEditClaudeSessionId} + messages, resume`);
+              const result = await restartClaudeHandler({
+                beforeRespawn: async () => {
+                  const target = resolveTranscriptPath(directory, meta.preEditClaudeSessionId);
+                  if (!restoreTranscriptFromUndo(undoDir, target)) {
+                    throw new Error("undo snapshot missing transcript backup");
+                  }
+                  restoreStoreA();
+                  claudeResumeId = meta.preEditClaudeSessionId;
+                  sessionMetadata = { ...sessionMetadata, claudeSessionId: claudeResumeId };
+                }
+              });
+              if (result.success) {
+                clearUndoSnapshot(undoDir);
+                if (claudeResumeId && !trackedSession.stopped) {
+                  saveSession({
+                    sessionId,
+                    directory,
+                    claudeResumeId,
+                    permissionMode: currentPermissionMode,
+                    spawnMeta: lastSpawnMeta,
+                    metadata: sessionMetadata,
+                    createdAt: sessionCreatedAt,
+                    machineId,
+                    wasProcessing: false
+                  });
+                  artifactSync.syncSession(sessionId, getSessionDir(directory, sessionId), sessionMetadata, machineId).catch(() => {
+                  });
+                }
+              }
+              return result;
+            },
             onUpdateSecurityContext: async (newSecurityContext) => {
               logger.log(`[Session ${sessionId}] Security context update requested \u2014 restarting agent`);
               sessionMetadata = { ...sessionMetadata, securityContext: newSecurityContext };
@@ -12976,7 +13403,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
       const specs = loadExposedTunnels();
       if (specs.length === 0) return;
       logger.log(`[exposed-tunnels] Restoring ${specs.length} tunnel(s) from ${EXPOSED_TUNNELS_FILE}`);
-      const { FrpcTunnel } = await import('./frpc-BjWZ129L.mjs');
+      const { FrpcTunnel } = await import('./frpc-1aSnPVrE.mjs');
       for (const spec of specs) {
         if (tunnels.has(spec.name)) continue;
         try {