svamp-cli 0.2.113 → 0.2.115

package/dist/{run-g8QqDNJ1.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';
@@ -10,8 +10,8 @@ import { existsSync, readFileSync, mkdirSync, readdirSync, writeFileSync, rename
 import { exec, execSync, spawn, execFile as execFile$1, execFileSync } from 'node:child_process';
 import { promisify } from 'util';
 import { join, basename, dirname } from 'node:path';
-import os, { homedir, platform } from 'node:os';
 import { EventEmitter } from 'node:events';
+import os, { homedir, platform } from 'node:os';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
@@ -1388,22 +1388,36 @@ function generateSkillBody(channel, ctx) {
   const bindNote = mode === "stateless" ? `**Stateless channel** \u2014 each call spawns a fresh, isolated one-shot session (cold-start: a few seconds), runs, replies, and closes. No shared memory between calls.` : mode === "fixed" ? `Routes to a **fixed session** (\`${rSession}\`); reachable only while that session is live.` : rSession ? `Routes to **session \`${rSession}\`** (the one this instruction was copied from); reachable only while it is live, else a fresh stateless run answers.` : `**Dynamic channel** \u2014 pass \`session: "<id>"\` to target a specific live session, else a fresh stateless run answers.`;
   const name = channel.skill?.name || channel.name;
   const desc = channel.skill?.description || channel.description || `Send a message to the "${channel.name}" channel.`;
-  const replyNote = isAgent ? `This is a **WISE Agent** channel: \`send()\` runs a fast assistant against the session's tools/skills and returns its answer synchronously in the result \`reply\`.` : isQueue ? `This is an **async** channel: \`send()\` returns a \`correlationId\` and the agent replies later \u2014 poll \`receive()\` (or GET /receive \xB7 /events) for replies addressed to you.` : `Delivery is fire-and-forget \u2014 the message lands in the agent's inbox, tagged with your verified identity (\`from\`).`;
+  const replyNote = isAgent ? `This is a **WISE Agent** channel: \`send()\` runs a fast assistant against the session's tools/skills and returns its answer synchronously in the result \`reply\`.` : isQueue ? `This is an **async** channel: \`send()\` usually returns \`{ status: "queued", correlationId }\` and the agent replies later \u2014 poll \`receive()\` (or GET /receive \xB7 /events) for replies addressed to you. **But it may also answer synchronously** with \`{ status: "completed", reply }\` (e.g. when the target session is gone and a fresh one-shot run handles the call) \u2014 always check \`status\` first and use \`reply\` directly when present; \`receive()\` has nothing to return for a one-shot.` : `Delivery is fire-and-forget \u2014 the message lands in the agent's inbox, tagged with your verified identity (\`from\`).`;
   const queueSection = isQueue ? `
 
-## Getting the reply (async)
-\`send()\` returns \`{ correlationId }\`. The agent answers later; retrieve replies addressed
-to you by **long-polling** \`receive\` with a cursor you advance each call:
+## Getting the reply
+\`send()\` returns one of two shapes \u2014 **check \`status\` first**:
+- \`{ status: "completed", reply, correlationId }\` \u2014 answered synchronously (e.g. a
+  dynamic channel whose target session is gone falls back to a fresh one-shot run).
+  Use \`reply\` directly; do **not** poll \`receive()\` \u2014 there is no persistent session
+  to poll and it will return an error.
+- \`{ status: "queued", correlationId }\` \u2014 a live session will answer later; long-poll
+  \`receive\` for replies addressed to you, advancing \`cursor\` each call:
 \`\`\`js
-const { correlationId } = await get_service("${svc}").send({ channel: "${channel.id}", message: "\u2026", from: "your-name" });
-let cursor = 0;
+const res = await get_service("${svc}").send({ channel: "${channel.id}", message: "\u2026", from: "your-name" });
+if (res.status === "completed") return res.reply;          // answered now \u2014 done
+let cursor = 0;                                            // else poll for the async reply
 while (true) {
   const r = await get_service("${svc}").receive({ channel: "${channel.id}", key: "${key}", cursor, wait: 25 });
   cursor = r.cursor;
-  for (const reply of r.replies) if (reply.correlationId === correlationId) return reply.body;
+  for (const reply of r.replies) if (reply.correlationId === res.correlationId) return reply.body;
 }
 \`\`\`
-**HTTP:** \`POST ${recvUrl}\` with \`{"kwargs": {"channel": "${channel.id}", "key": "${key}", "cursor": 0, "wait": 25}}\` (long-poll), or stream \`GET <channel-http>/channel/${channel.id}/events?key=${key}\` (SSE).` : "";
+**HTTP:** \`POST ${recvUrl}\` with \`{"kwargs": {"channel": "${channel.id}", "key": "${key}", "cursor": 0, "wait": 25}}\` (long-poll), or stream \`GET <channel-http>/channel/${channel.id}/events?key=${key}\` (SSE).
+
+### Agent-to-agent: get the reply in your own inbox
+If **you are a Svamp agent session**, pass \`reply_to: { session: "<your-session-id>" }\`
+to \`send()\`. The reply is then delivered straight to **your session's inbox**
+(\`inbox reply\`-able, persistent) \u2014 symmetric agent\u2194agent messaging. Without
+\`reply_to.session\` you are treated as an **external caller**: the reply goes to this
+channel's outbox and you must poll \`receive()\` (above) for it \u2014 it will **not** appear
+in your inbox.` : "";
   const rpcLine = hyphaOpen ? `**Hypha RPC** \u2014 preferred. Your verified Hypha identity is accepted, no key needed:` : `**Hypha RPC** \u2014 verified identity:`;
   return `---
 name: ${name}
@@ -1449,7 +1463,10 @@ function resolveSender(channel, input = {}) {
   }
   if (id.mode === "per-key") {
     const caller = (id.callers || []).find((c) => c.key && c.key === key);
-    if (!caller) return { error: "invalid or missing key" };
+    if (!caller) {
+      const acceptsHypha = Array.isArray(id.hypha_allow) && id.hypha_allow.length > 0;
+      return { error: acceptsHypha ? "invalid or missing key \u2014 supply a caller key issued by the channel owner, or call with an authenticated Hypha identity (this channel accepts hypha_allow callers; anonymous/keyless requests are rejected)" : "invalid or missing key \u2014 this channel requires a caller key issued by the channel owner" };
+    }
     return { sender: { name: caller.name, kind: caller.kind, verified: true } };
   }
   if (id.mode === "caller-supplied") {
@@ -1482,6 +1499,138 @@ function renderMessage(channel, { sender = {}, body = {}, query = {}, callId, no
   return renderTemplate(channel.template || DEFAULT_TEMPLATE, ctx);
 }
 
+const MAX_PER_CHANNEL = 200;
+const TTL_MS = 60 * 60 * 1e3;
+class ChannelOutbox {
+  file;
+  byChannel = /* @__PURE__ */ new Map();
+  seqByChannel = /* @__PURE__ */ new Map();
+  emitter = new EventEmitter();
+  constructor(projectDir) {
+    const dir = join(projectDir, ".svamp", "channels");
+    this.file = join(dir, "_outbox.jsonl");
+    this.emitter.setMaxListeners(0);
+    try {
+      mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+    this._load();
+  }
+  _load() {
+    if (!existsSync(this.file)) return;
+    const cutoff = Date.now() - TTL_MS;
+    try {
+      for (const line of readFileSync(this.file, "utf8").split("\n")) {
+        if (!line.trim()) continue;
+        let rec = null;
+        try {
+          rec = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (!rec || rec.ts < cutoff) continue;
+        const { channelId, ...reply } = rec;
+        const arr = this.byChannel.get(channelId) || [];
+        arr.push(reply);
+        this.byChannel.set(channelId, arr);
+        this.seqByChannel.set(channelId, Math.max(this.seqByChannel.get(channelId) || 0, reply.seq));
+      }
+      for (const [ch, arr] of this.byChannel) if (arr.length > MAX_PER_CHANNEL) this.byChannel.set(ch, arr.slice(-MAX_PER_CHANNEL));
+    } catch {
+    }
+  }
+  _evict(channelId) {
+    const cutoff = Date.now() - TTL_MS;
+    let arr = this.byChannel.get(channelId);
+    if (!arr) return;
+    if (arr.some((r) => r.ts < cutoff)) arr = arr.filter((r) => r.ts >= cutoff);
+    if (arr.length > MAX_PER_CHANNEL) arr = arr.slice(-MAX_PER_CHANNEL);
+    this.byChannel.set(channelId, arr);
+  }
+  /** Append a reply addressed to `to`. Assigns seq + ts, persists, and wakes waiters. */
+  append(channelId, r) {
+    const seq = (this.seqByChannel.get(channelId) || 0) + 1;
+    this.seqByChannel.set(channelId, seq);
+    const reply = { seq, ts: Date.now(), to: r.to, body: r.body, ...r.correlationId ? { correlationId: r.correlationId } : {} };
+    const arr = this.byChannel.get(channelId) || [];
+    arr.push(reply);
+    this.byChannel.set(channelId, arr);
+    this._evict(channelId);
+    try {
+      appendFileSync(this.file, JSON.stringify({ channelId, ...reply }) + "\n");
+    } catch {
+      try {
+        mkdirSync(join(this.file, ".."), { recursive: true });
+        appendFileSync(this.file, JSON.stringify({ channelId, ...reply }) + "\n");
+      } catch {
+      }
+    }
+    this.emitter.emit(channelId, reply);
+    return reply;
+  }
+  /** Replies for `to` on `channelId` with seq > cursor (optionally one correlationId). */
+  since(channelId, cursor, to, correlationId) {
+    this._evict(channelId);
+    return (this.byChannel.get(channelId) || []).filter((r) => r.seq > cursor && r.to === to && (!correlationId || r.correlationId === correlationId));
+  }
+  /** Highest seq on a channel (the cursor a caller gets back). */
+  cursor(channelId) {
+    return this.seqByChannel.get(channelId) || 0;
+  }
+  /**
+   * Long-poll: resolve immediately if there are replies after `cursor`, else wait for
+   * the next append (filtered to this channel + `to`) or `timeoutMs`, then return.
+   */
+  wait(channelId, cursor, to, timeoutMs, correlationId) {
+    const ready = this.since(channelId, cursor, to, correlationId);
+    if (ready.length) return Promise.resolve({ replies: ready, cursor: this.cursor(channelId) });
+    return new Promise((resolve) => {
+      const onReply = (r) => {
+        if (r.to !== to || correlationId && r.correlationId !== correlationId) return;
+        cleanup();
+        resolve({ replies: this.since(channelId, cursor, to, correlationId), cursor: this.cursor(channelId) });
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        resolve({ replies: [], cursor: this.cursor(channelId) });
+      }, Math.max(0, timeoutMs));
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.emitter.off(channelId, onReply);
+      };
+      this.emitter.on(channelId, onReply);
+    });
+  }
+  /** Push subscription for SSE: calls onReply for each new reply addressed to `to`. */
+  subscribe(channelId, to, onReply) {
+    const handler = (r) => {
+      if (r.to === to) onReply(r);
+    };
+    this.emitter.on(channelId, handler);
+    return () => this.emitter.off(channelId, handler);
+  }
+  /** Drop a channel's outbox (on channel delete) — best-effort rewrite of the log. */
+  purge(channelId) {
+    this.byChannel.delete(channelId);
+    this.seqByChannel.delete(channelId);
+    if (!existsSync(this.file)) return;
+    try {
+      const kept = readFileSync(this.file, "utf8").split("\n").filter((l) => {
+        if (!l.trim()) return false;
+        try {
+          return JSON.parse(l).channelId !== channelId;
+        } catch {
+          return false;
+        }
+      });
+      const tmp = this.file + ".tmp";
+      writeFileSync(tmp, kept.join("\n") + (kept.length ? "\n" : ""));
+      renameSync(tmp, this.file);
+    } catch {
+    }
+  }
+}
+
 function getParamNames(fn) {
   const src = fn.toString();
   const match = src.match(/^(?:async\s+)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
@@ -2527,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-fsq8Ua7l.mjs');
+        const { FrpcTunnel } = await import('./frpc-1aSnPVrE.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -2788,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-uW543Qst.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);
         }
@@ -2887,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-OvJA3HMg.mjs');
+    const { queryCore } = await import('./commands-B3NhziMR.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -2904,7 +3053,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
     }
     if (result.status === "error") return { ok: false, call_id: callId, status: "error", error: result.error };
     if (result.status === "permission-pending") return { ok: false, call_id: callId, status: "permission-pending", error: result.error };
-    return { ok: true, call_id: callId, status: "completed", reply: result.response };
+    return { ok: true, call_id: callId, correlationId: callId, status: "completed", reply: result.response };
   };
   const channelsServiceInfo = await server.registerService(
     {
@@ -2925,10 +3074,16 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
         }
         return out;
       },
-      describe: async (kwargs = {}) => {
-        const rpc = await findChannelOwner(kwargs.channel);
+      // Accept a plain `?channel=<id>` GET (positional, like `skill`) AS WELL AS
+      // the kwargs-wrapped form. The Hypha HTTP gateway only maps a `?channel=`
+      // query onto a param literally named `channel`; a kwargs-only signature left
+      // `channel` undefined on GET, so describe() 404'd on every channel that
+      // list() returned. Normalize both the string and `{channel}` object shapes.
+      describe: async (channel) => {
+        const id = typeof channel === "string" ? channel : channel?.channel;
+        const rpc = id ? await findChannelOwner(id) : void 0;
         if (!rpc?.channelDescribe) return { error: "channel not found" };
-        return rpc.channelDescribe(kwargs.channel);
+        return rpc.channelDescribe(id);
       },
       // Clean GET endpoint for the self-contained skill markdown. Param is
       // named `channel` (not `kwargs`) so the Hypha HTTP gateway maps a plain
@@ -2958,9 +3113,26 @@ ${d?.error || "not found"}`;
         trackInbound();
         const res = resolveChannel(kwargs.channel, kwargs.session);
         if ("error" in res) return { error: res.error };
-        if (res.tier === "stateless") return { error: "stateless channels have no async replies (no persistent session)" };
-        if ("stopped" in res) return { error: `session ${res.sessionId.slice(0, 8)} is stopped` };
-        return res.rpc.channelReceive({ channel: kwargs.channel, key: kwargs.key, from: kwargs.from, cursor: kwargs.cursor, correlationId: kwargs.correlationId, wait: kwargs.wait }, context);
+        if (res.tier === "session" && !("stopped" in res)) {
+          return res.rpc.channelReceive({ channel: kwargs.channel, key: kwargs.key, from: kwargs.from, cursor: kwargs.cursor, correlationId: kwargs.correlationId, wait: kwargs.wait }, context);
+        }
+        const { c, dir } = res;
+        if (c.reply?.mode !== "queue") {
+          return { error: "this channel has no async replies (not a queue-mode channel)" };
+        }
+        const u = context?.user;
+        const r = resolveSender(c, {
+          key: kwargs.key,
+          from: kwargs.from,
+          hyphaUser: u && u.is_anonymous !== true ? u.email || u.id : void 0,
+          hyphaAnonymous: u?.is_anonymous === true,
+          hyphaWorkspace: u?.scope?.current_workspace
+        });
+        if (r.error || !r.sender) return { error: r.error || "unauthorized" };
+        const cursor = Math.max(0, Number(kwargs.cursor) || 0);
+        const outbox = new ChannelOutbox(dir);
+        const replies = outbox.since(c.id, cursor, r.sender.name, kwargs.correlationId);
+        return { ok: true, replies, cursor: outbox.cursor(c.id) };
       }
     },
     { overwrite: true }
@@ -3202,138 +3374,6 @@ class RoutineRunner {
   }
 }
 
-const MAX_PER_CHANNEL = 200;
-const TTL_MS = 60 * 60 * 1e3;
-class ChannelOutbox {
-  file;
-  byChannel = /* @__PURE__ */ new Map();
-  seqByChannel = /* @__PURE__ */ new Map();
-  emitter = new EventEmitter();
-  constructor(projectDir) {
-    const dir = join(projectDir, ".svamp", "channels");
-    this.file = join(dir, "_outbox.jsonl");
-    this.emitter.setMaxListeners(0);
-    try {
-      mkdirSync(dir, { recursive: true });
-    } catch {
-    }
-    this._load();
-  }
-  _load() {
-    if (!existsSync(this.file)) return;
-    const cutoff = Date.now() - TTL_MS;
-    try {
-      for (const line of readFileSync(this.file, "utf8").split("\n")) {
-        if (!line.trim()) continue;
-        let rec = null;
-        try {
-          rec = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        if (!rec || rec.ts < cutoff) continue;
-        const { channelId, ...reply } = rec;
-        const arr = this.byChannel.get(channelId) || [];
-        arr.push(reply);
-        this.byChannel.set(channelId, arr);
-        this.seqByChannel.set(channelId, Math.max(this.seqByChannel.get(channelId) || 0, reply.seq));
-      }
-      for (const [ch, arr] of this.byChannel) if (arr.length > MAX_PER_CHANNEL) this.byChannel.set(ch, arr.slice(-MAX_PER_CHANNEL));
-    } catch {
-    }
-  }
-  _evict(channelId) {
-    const cutoff = Date.now() - TTL_MS;
-    let arr = this.byChannel.get(channelId);
-    if (!arr) return;
-    if (arr.some((r) => r.ts < cutoff)) arr = arr.filter((r) => r.ts >= cutoff);
-    if (arr.length > MAX_PER_CHANNEL) arr = arr.slice(-MAX_PER_CHANNEL);
-    this.byChannel.set(channelId, arr);
-  }
-  /** Append a reply addressed to `to`. Assigns seq + ts, persists, and wakes waiters. */
-  append(channelId, r) {
-    const seq = (this.seqByChannel.get(channelId) || 0) + 1;
-    this.seqByChannel.set(channelId, seq);
-    const reply = { seq, ts: Date.now(), to: r.to, body: r.body, ...r.correlationId ? { correlationId: r.correlationId } : {} };
-    const arr = this.byChannel.get(channelId) || [];
-    arr.push(reply);
-    this.byChannel.set(channelId, arr);
-    this._evict(channelId);
-    try {
-      appendFileSync(this.file, JSON.stringify({ channelId, ...reply }) + "\n");
-    } catch {
-      try {
-        mkdirSync(join(this.file, ".."), { recursive: true });
-        appendFileSync(this.file, JSON.stringify({ channelId, ...reply }) + "\n");
-      } catch {
-      }
-    }
-    this.emitter.emit(channelId, reply);
-    return reply;
-  }
-  /** Replies for `to` on `channelId` with seq > cursor (optionally one correlationId). */
-  since(channelId, cursor, to, correlationId) {
-    this._evict(channelId);
-    return (this.byChannel.get(channelId) || []).filter((r) => r.seq > cursor && r.to === to && (!correlationId || r.correlationId === correlationId));
-  }
-  /** Highest seq on a channel (the cursor a caller gets back). */
-  cursor(channelId) {
-    return this.seqByChannel.get(channelId) || 0;
-  }
-  /**
-   * Long-poll: resolve immediately if there are replies after `cursor`, else wait for
-   * the next append (filtered to this channel + `to`) or `timeoutMs`, then return.
-   */
-  wait(channelId, cursor, to, timeoutMs, correlationId) {
-    const ready = this.since(channelId, cursor, to, correlationId);
-    if (ready.length) return Promise.resolve({ replies: ready, cursor: this.cursor(channelId) });
-    return new Promise((resolve) => {
-      const onReply = (r) => {
-        if (r.to !== to || correlationId && r.correlationId !== correlationId) return;
-        cleanup();
-        resolve({ replies: this.since(channelId, cursor, to, correlationId), cursor: this.cursor(channelId) });
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        resolve({ replies: [], cursor: this.cursor(channelId) });
-      }, Math.max(0, timeoutMs));
-      const cleanup = () => {
-        clearTimeout(timer);
-        this.emitter.off(channelId, onReply);
-      };
-      this.emitter.on(channelId, onReply);
-    });
-  }
-  /** Push subscription for SSE: calls onReply for each new reply addressed to `to`. */
-  subscribe(channelId, to, onReply) {
-    const handler = (r) => {
-      if (r.to === to) onReply(r);
-    };
-    this.emitter.on(channelId, handler);
-    return () => this.emitter.off(channelId, handler);
-  }
-  /** Drop a channel's outbox (on channel delete) — best-effort rewrite of the log. */
-  purge(channelId) {
-    this.byChannel.delete(channelId);
-    this.seqByChannel.delete(channelId);
-    if (!existsSync(this.file)) return;
-    try {
-      const kept = readFileSync(this.file, "utf8").split("\n").filter((l) => {
-        if (!l.trim()) return false;
-        try {
-          return JSON.parse(l).channelId !== channelId;
-        } catch {
-          return false;
-        }
-      });
-      const tmp = this.file + ".tmp";
-      writeFileSync(tmp, kept.join("\n") + (kept.length ? "\n" : ""));
-      renameSync(tmp, this.file);
-    } catch {
-    }
-  }
-}
-
 function channelPublicView(c) {
   return { id: c.id, name: c.name, description: c.description, identity: { mode: c.identity?.mode }, action: c.action?.kind, bind: c.bind };
 }
@@ -3439,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;
@@ -3584,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) => {
@@ -3870,7 +4046,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
           const result = await dispatchAgentChannel({ channel: c, sender: r.sender, message: rendered, deps, env: process.env });
           channelStore.recordCall(c.id, { sender: r.sender.name, verified: r.sender.verified, callId, outcome: result.status });
           syncChannelsToMetadata();
-          return { ok: result.status === "completed", call_id: callId, status: result.status, reply: result.reply, tool_calls: result.toolCalls, error: result.error };
+          return { ok: result.status === "completed", call_id: callId, correlationId: callId, status: result.status, reply: result.reply, tool_calls: result.toolCalls, error: result.error };
         }
         if (c.action?.kind === "loop") return { error: "loop channels are served by the channel server, not channelSend" };
         const queue = c.reply?.mode === "queue";
@@ -4263,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 = {
@@ -7149,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");
@@ -10451,7 +10805,7 @@ async function startDaemon(options) {
     const list = loadExposedTunnels().filter((t) => t.name !== name);
     saveExposedTunnels(list);
   }
-  const { ServeManager } = await import('./serveManager-DX5SdhTq.mjs');
+  const { ServeManager } = await import('./serveManager-BnwAe-VX.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -11503,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;
@@ -11520,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 {
@@ -11532,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`);
@@ -11545,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);
@@ -11565,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 {
@@ -11784,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 };
@@ -12936,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-fsq8Ua7l.mjs');
+      const { FrpcTunnel } = await import('./frpc-1aSnPVrE.mjs');
       for (const spec of specs) {
         if (tunnels.has(spec.name)) continue;
         try {