svamp-cli 0.2.119 → 0.2.121

package/dist/{run-9C2ogsuu.mjs → run-CCjAePDZ.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-CdcXdQde.mjs');
+        const { FrpcTunnel } = await import('./frpc-DRWpAeZW.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-BHWq1P8E.mjs');
+          const { toolsForRole } = await import('./sideband-DDiW5TJU.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-B5rek8XG.mjs');
+    const { queryCore } = await import('./commands-DgrVRMPf.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3113,9 +3113,6 @@ ${d?.error || "not found"}`;
         trackInbound();
         const res = resolveChannel(kwargs.channel, kwargs.session);
         if ("error" in res) return { error: res.error };
-        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)" };
@@ -3130,9 +3127,16 @@ ${d?.error || "not found"}`;
         });
         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) };
+        const waitMs = Math.min(Math.max(0, Number(kwargs.wait ?? 25) * 1e3), 6e4);
+        const deadline = Date.now() + waitMs;
+        for (; ; ) {
+          const outbox = new ChannelOutbox(dir);
+          const replies = outbox.since(c.id, cursor, r.sender.name, kwargs.correlationId);
+          if (replies.length || Date.now() >= deadline) {
+            return { ok: true, replies, cursor: outbox.cursor(c.id) };
+          }
+          await new Promise((resolve) => setTimeout(resolve, 500));
+        }
       }
     },
     { overwrite: true }
@@ -3389,6 +3393,7 @@ function formatInboxMessageXml(msg) {
   if (msg.from) attrs.push(`from="${escapeXml(msg.from)}"`);
   if (msg.channel) attrs.push(`channel="${escapeXml(msg.channel)}"`);
   if (msg.verified !== void 0) attrs.push(`verified="${msg.verified === true}"`);
+  if (msg.channelId && msg.correlationId) attrs.push(`awaiting-reply="true"`);
   if (msg.to) attrs.push(`to="${escapeXml(msg.to)}"`);
   if (msg.subject) attrs.push(`subject="${escapeXml(msg.subject)}"`);
   if (msg.urgency) attrs.push(`urgency="${msg.urgency}"`);
@@ -3479,6 +3484,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 +3671,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 +4444,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 = {
@@ -4447,6 +4601,298 @@ function shortId(length = 10) {
   return out;
 }
 
+const ADJECTIVES = [
+  "able",
+  "amber",
+  "amused",
+  "ancient",
+  "arctic",
+  "autumn",
+  "azure",
+  "blithe",
+  "bold",
+  "brave",
+  "breezy",
+  "bright",
+  "brisk",
+  "calm",
+  "candid",
+  "cheery",
+  "chill",
+  "clever",
+  "cobalt",
+  "cosmic",
+  "cozy",
+  "crimson",
+  "crisp",
+  "curious",
+  "dapper",
+  "daring",
+  "dawn",
+  "deft",
+  "dewy",
+  "eager",
+  "early",
+  "easy",
+  "electric",
+  "fancy",
+  "feisty",
+  "fleet",
+  "fond",
+  "frosty",
+  "gallant",
+  "gentle",
+  "giddy",
+  "glad",
+  "gleaming",
+  "golden",
+  "graceful",
+  "grand",
+  "hardy",
+  "hazel",
+  "hearty",
+  "honest",
+  "humble",
+  "jolly",
+  "jovial",
+  "keen",
+  "kind",
+  "lively",
+  "loyal",
+  "lucky",
+  "lunar",
+  "mellow",
+  "merry",
+  "mighty",
+  "mint",
+  "misty",
+  "nimble",
+  "noble",
+  "opal",
+  "patient",
+  "peppy",
+  "placid",
+  "plucky",
+  "polar",
+  "prim",
+  "proud",
+  "quick",
+  "quiet",
+  "quirky",
+  "radiant",
+  "rapid",
+  "ready",
+  "regal",
+  "rosy",
+  "royal",
+  "rugged",
+  "sage",
+  "sandy",
+  "scarlet",
+  "serene",
+  "sharp",
+  "shiny",
+  "silent",
+  "silver",
+  "sleek",
+  "smooth",
+  "snappy",
+  "snowy",
+  "solar",
+  "spry",
+  "stellar",
+  "sturdy",
+  "sunny",
+  "swift",
+  "tender",
+  "tidal",
+  "tidy",
+  "tranquil",
+  "trusty",
+  "upbeat",
+  "valiant",
+  "vivid",
+  "warm",
+  "whimsical",
+  "wise",
+  "witty",
+  "zesty",
+  "zippy"
+];
+const ANIMALS = [
+  "ant",
+  "badger",
+  "bat",
+  "bear",
+  "beaver",
+  "bee",
+  "bison",
+  "boar",
+  "bobcat",
+  "buffalo",
+  "camel",
+  "caribou",
+  "cat",
+  "cheetah",
+  "cobra",
+  "condor",
+  "cougar",
+  "coyote",
+  "crab",
+  "crane",
+  "cricket",
+  "crow",
+  "deer",
+  "dingo",
+  "dolphin",
+  "donkey",
+  "dove",
+  "dragon",
+  "duck",
+  "eagle",
+  "eel",
+  "egret",
+  "elk",
+  "falcon",
+  "ferret",
+  "finch",
+  "fox",
+  "frog",
+  "gecko",
+  "gibbon",
+  "goat",
+  "goose",
+  "gopher",
+  "hare",
+  "hawk",
+  "hedgehog",
+  "heron",
+  "hippo",
+  "horse",
+  "ibex",
+  "ibis",
+  "iguana",
+  "jackal",
+  "jaguar",
+  "jay",
+  "kestrel",
+  "koala",
+  "krill",
+  "lark",
+  "lemur",
+  "leopard",
+  "lion",
+  "llama",
+  "lynx",
+  "macaw",
+  "magpie",
+  "mantis",
+  "marmot",
+  "marten",
+  "meerkat",
+  "mink",
+  "mole",
+  "moose",
+  "moth",
+  "mouse",
+  "newt",
+  "ocelot",
+  "octopus",
+  "orca",
+  "osprey",
+  "otter",
+  "owl",
+  "ox",
+  "panda",
+  "panther",
+  "parrot",
+  "pelican",
+  "penguin",
+  "pheasant",
+  "pigeon",
+  "puffin",
+  "puma",
+  "quail",
+  "rabbit",
+  "raccoon",
+  "ram",
+  "raven",
+  "robin",
+  "salmon",
+  "seal",
+  "shark",
+  "sheep",
+  "shrew",
+  "skunk",
+  "sloth",
+  "snail",
+  "sparrow",
+  "spider",
+  "squid",
+  "stag",
+  "stoat",
+  "stork",
+  "swan",
+  "tapir",
+  "tiger",
+  "toad",
+  "trout",
+  "turtle",
+  "viper",
+  "vole",
+  "walrus",
+  "weasel",
+  "whale",
+  "wolf",
+  "wombat",
+  "wren",
+  "yak",
+  "zebra"
+];
+function pick(arr) {
+  const n = arr.length;
+  const max = Math.floor(256 / n) * n;
+  let b;
+  do {
+    b = randomBytes(1)[0];
+  } while (b >= max);
+  return arr[b % n];
+}
+function generateFriendlyName(taken = []) {
+  const used = taken instanceof Set ? taken : new Set(taken);
+  for (let i = 0; i < 1e3; i++) {
+    const name = `${pick(ADJECTIVES)}-${pick(ANIMALS)}`;
+    if (!used.has(name)) return name;
+  }
+  const base = `${pick(ADJECTIVES)}-${pick(ANIMALS)}`;
+  let n = 2;
+  while (used.has(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+function sanitizeSegment(s) {
+  return String(s || "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function formatHandle(projectName, friendlyName) {
+  if (!friendlyName) return void 0;
+  const proj = sanitizeSegment(projectName || "");
+  return proj ? `${proj}:${friendlyName}` : friendlyName;
+}
+function parseHandle(input) {
+  const str = String(input || "").trim().replace(/^@/, "");
+  if (!str) return null;
+  const i = str.indexOf(":");
+  if (i === -1) return { name: str.toLowerCase() };
+  return { project: sanitizeSegment(str.slice(0, i)), name: str.slice(i + 1).toLowerCase() };
+}
+function handleMatchesMetadata(parsed, metadata) {
+  const fn = String(metadata?.friendlyName || "").toLowerCase();
+  if (!fn || fn !== parsed.name) return false;
+  if (parsed.project) {
+    return sanitizeSegment(metadata?.projectName || "") === parsed.project;
+  }
+  return true;
+}
+
 const SVAMP_HOME$2 = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
 const num = (key, def) => {
   const v = Number(process.env[key]);
@@ -7189,6 +7635,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");
@@ -9079,6 +9690,111 @@ class ProcessSupervisor {
   }
 }
 
+const STATUS_TO_MARKER = {
+  todo: " ",
+  active: "~",
+  verifying: "*",
+  awaiting_review: "?",
+  rework: "r",
+  blocked: "!",
+  done: "x"
+};
+function renderCriteria(items) {
+  if (!items.length) return "";
+  const lines = items.map((it) => {
+    const tag = it.disposition === "delegated" ? " (delegated)" : "";
+    return `- [${STATUS_TO_MARKER[it.status] ?? " "}] ${it.text}${tag}`;
+  });
+  const { done, total } = summarize(items);
+  return `Success criteria \u2014 drive this checklist to all-done (${done}/${total}):
+${lines.join("\n")}`;
+}
+function compileChecklist(items) {
+  const criteria = renderCriteria(items);
+  const oracleItem = items.find((i) => i.disposition === "inline" && i.eval?.type === "oracle");
+  const oracle = oracleItem && oracleItem.eval?.type === "oracle" ? oracleItem.eval.cmd : void 0;
+  return { criteria, ...oracle ? { oracle } : {} };
+}
+function routeVerdictToChecklist(items, v) {
+  let matched = false;
+  const next = items.map((it) => {
+    if (it.child?.sessionId && it.child.sessionId === v.sessionId) {
+      matched = true;
+      return applyVerdict(it, v);
+    }
+    return it;
+  });
+  return { items: next, matched };
+}
+function applyVerdict(item, v) {
+  const lastVerdict = { verdict: v.verdict, ...v.guidance ? { guidance: v.guidance } : {}, round: v.round, ts: v.ts };
+  if (v.verdict === "approved") return { ...item, status: "done", doneAt: Date.parse(v.ts) || item.createdAt, lastVerdict };
+  return { ...item, status: "rework", lastVerdict };
+}
+const VALID_STATUS = /* @__PURE__ */ new Set(["todo", "active", "verifying", "awaiting_review", "rework", "blocked", "done"]);
+function validateChecklist(items) {
+  const errs = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const it of items) {
+    if (!it.id) errs.push("item missing id");
+    else if (ids.has(it.id)) errs.push(`duplicate item id "${it.id}"`);
+    else ids.add(it.id);
+    if (!it.text || !it.text.trim()) errs.push(`item "${it.id}" has empty text`);
+    if (it.disposition !== "inline" && it.disposition !== "delegated") errs.push(`item "${it.id}" bad disposition`);
+    if (!VALID_STATUS.has(it.status)) errs.push(`item "${it.id}" bad status "${it.status}"`);
+    if (it.eval?.type === "oracle" && !it.eval.cmd.trim()) errs.push(`item "${it.id}" oracle eval needs a cmd`);
+  }
+  return errs;
+}
+function summarize(items) {
+  const by = (s) => items.filter((i) => i.status === s).length;
+  const done = by("done");
+  return {
+    total: items.length,
+    done,
+    todo: by("todo"),
+    active: by("active"),
+    blocked: by("blocked"),
+    awaiting_review: by("awaiting_review"),
+    delegated: items.filter((i) => i.disposition === "delegated").length,
+    allDone: items.length > 0 && done === items.length
+  };
+}
+function checklistPath(projectRoot, sessionId) {
+  return join(projectRoot, ".svamp", sessionId, "loop", "checklist.json");
+}
+
+function readChecklist(projectRoot, sessionId) {
+  const p = checklistPath(projectRoot, sessionId);
+  if (!existsSync(p)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(p, "utf8"));
+    return Array.isArray(parsed?.items) ? parsed.items : [];
+  } catch {
+    return [];
+  }
+}
+function writeChecklist(projectRoot, sessionId, items) {
+  const p = checklistPath(projectRoot, sessionId);
+  mkdirSync(dirname(p), { recursive: true });
+  const file = { version: 1, items, updatedAt: Date.now() };
+  const tmp = p + ".tmp";
+  writeFileSync(tmp, JSON.stringify(file, null, 2));
+  renameSync(tmp, p);
+}
+function clearChecklist(projectRoot, sessionId) {
+  const p = checklistPath(projectRoot, sessionId);
+  try {
+    if (existsSync(p)) rmSync(p);
+  } catch {
+  }
+}
+function mutateChecklist(projectRoot, sessionId, fn) {
+  const next = fn(readChecklist(projectRoot, sessionId));
+  writeChecklist(projectRoot, sessionId, next);
+  return next;
+}
+
 const OAUTH_TOKEN_ENDPOINT = "https://platform.claude.com/v1/oauth/token";
 const OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
 const OAUTH_SCOPES = "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
@@ -9162,10 +9878,10 @@ async function checkAndRefreshOAuthToken(force = false, logger) {
   }
 }
 
-function buildBaselineSystemPrompt(sessionId) {
+function buildBaselineSystemPrompt(sessionId, handle) {
   return `# Svamp Session
 
-You are running inside a Svamp session (id: ${sessionId}) on Hypha Cloud. Use the \`svamp\` CLI to manage session state (title, link, notify) and the \`hypha\` CLI for artifacts, tokens, and RPC services. Installed skills live in \`~/.claude/skills/\` \u2014 read them for full references.
+You are running inside a Svamp session (id: ${sessionId}${handle ? `, handle: ${handle}` : ""}) on Hypha Cloud.${handle ? ` Other agents and the user refer to you as \`${handle}\` (a \`project:name\` handle) \u2014 use it when introducing yourself, and refer to peers by their handles.` : ""} Use the \`svamp\` CLI to manage session state (title, link, notify) and the \`hypha\` CLI for artifacts, tokens, and RPC services. Installed skills live in \`~/.claude/skills/\` \u2014 read them for full references.
 
 **Session state:**
 - \`svamp session set-title "<topic>"\` \u2014 your session topic: a short sentence describing what you're working on. It's the index the user and other agents see when listing sessions, so set it after your first reply and update it as focus shifts (else it's auto-summarized for you).
@@ -9178,7 +9894,7 @@ You are running inside a Svamp session (id: ${sessionId}) on Hypha Cloud. Use th
 
 You share this machine and project folder with other agent sessions (same user, possibly other machines too). When collaboration, coordination, or avoiding edit conflicts becomes relevant, run \`svamp session whoami\` \u2014 it shows who's around and how to reach them. Keep cross-agent contact purposeful: only initiate with a concrete reason, avoid ping-pong loops.
 
-**Inbox messages from other agents** arrive wrapped as \`<svamp-message message-id="\u2026" from="agent:\u2026" \u2026>BODY</svamp-message>\` (a plain user turn has no wrapper). Reply only when useful: \`svamp session inbox reply <message-id> "<body>"\` \u2014 the message-id is all you need; routing back to the sender is automatic.
+**Inbox messages from other agents** arrive wrapped as \`<svamp-message message-id="\u2026" from="<sender-handle>" \u2026>BODY</svamp-message>\` (a plain user turn has no wrapper); \`from\` is the sender's \`project:name\` handle. Reply only when useful: \`svamp session inbox reply <message-id> "<body>"\` \u2014 the message-id is all you need; routing back to the sender is automatic. **If a message carries \`awaiting-reply="true"\`, the sender is actively polling for your answer through a channel \u2014 you MUST respond with \`svamp session inbox reply <message-id> "<body>"\`; a normal chat reply will NOT reach them.**
 `;
 }
 
@@ -10097,6 +10813,8 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
             messageQueue: [...existingQueue, {
               id: randomUUID$1(),
               text: kickoff,
+              // Compact chat badge; full task lives in LOOP.md. Show an ellipsis
+              // when truncated so it's clear the preview is shortened, not the task.
               displayText: `\u{1F501} Loop started: ${lp.task.trim().slice(0, 100)}${lp.task.trim().length > 100 ? "\u2026" : ""}`,
               createdAt: Date.now()
             }]
@@ -10169,6 +10887,38 @@ Continue working until they are met, or verify and finish \u2014 an independent
       const { supervisor: _s, ...restPatch } = patch;
       patch = restPatch;
     }
+    if ("checklist" in patch) {
+      const raw = patch.checklist;
+      const items = Array.isArray(raw) ? raw : [];
+      if (items.length) {
+        const errs = validateChecklist(items);
+        if (errs.length) {
+          sessionService.pushMessage({ type: "message", message: `Checklist rejected: ${errs.join("; ")}`, level: "error" }, "event");
+        } else {
+          writeChecklist(directory, sessionId, items);
+          const { criteria, oracle } = compileChecklist(items);
+          const ok = initLoop(directory, { task: criteria, criteria, oracle, maxIterations: 20, evaluator: true, sessionId });
+          const s = summarize(items);
+          if (ok) {
+            const idle = getMetadata().lifecycleState === "idle";
+            if (idle) {
+              const q = getMetadata().messageQueue || [];
+              const nudge = `Your goal checklist was updated (${s.done}/${s.total} done). Work the open items in order; an independent Stop gate re-checks the criteria before you can stop.`;
+              setMetadata((m) => ({ ...m, messageQueue: [...q, { id: randomUUID$1(), text: nudge, displayText: `\u{1F4CB} Checklist updated`, createdAt: Date.now() }] }));
+              onLoopActivated?.();
+            }
+            sessionService.pushMessage({ type: "message", message: `\u{1F4CB} Checklist set \u2014 ${s.total} item${s.total === 1 ? "" : "s"} (${s.delegated} delegated), ${s.done} done.` }, "event");
+            logger.log(`[svampConfig] Checklist set (${s.total} items, ${s.delegated} delegated)`);
+          }
+        }
+      } else {
+        clearChecklist(directory, sessionId);
+        deactivateLoop(directory, sessionId);
+        sessionService.pushMessage({ type: "message", message: "Checklist cleared." }, "event");
+      }
+      const { checklist: _c, ...restPatch } = patch;
+      patch = restPatch;
+    }
     if (Object.keys(patch).length > 0) {
       const config = readSvampConfig(configPath);
       for (const [key, value] of Object.entries(patch)) {
@@ -10596,7 +11346,7 @@ async function startDaemon(options) {
     const list = loadExposedTunnels().filter((t) => t.name !== name);
     saveExposedTunnels(list);
   }
-  const { ServeManager } = await import('./serveManager-XsXnI804.mjs');
+  const { ServeManager } = await import('./serveManager-BSwiPu1O.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -10622,6 +11372,16 @@ async function startDaemon(options) {
       clientId: hyphaClientId || machineId
     });
     logger.log(`Connected to Hypha (workspace: ${server.config.workspace})`);
+    writeDaemonStateFile({
+      pid: process.pid,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      version: DAEMON_VERSION,
+      hyphaServerUrl,
+      workspace: server.config.workspace,
+      machineId,
+      hyphaClientId: server.config.client_id,
+      supervised: process.env.SVAMP_SUPERVISED === "1"
+    });
     server.on("disconnected", (reason) => {
       logger.log(`Hypha connection permanently lost: ${reason}. Daemon continues running \u2014 restart manually to reconnect.`);
     });
@@ -10647,6 +11407,13 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
           hopCount: 1
         })).catch(() => {
         });
+        try {
+          if (parent?.directory) {
+            const res = mutateChecklist(parent.directory, parentId, (items) => routeVerdictToChecklist(items, { sessionId: v.sessionId, verdict: v.verdict, guidance: v.guidance, round: v.round, ts: v.ts }).items);
+            if (res.some((i) => i.child?.sessionId === v.sessionId)) logger.log(`[supervision] reflected '${v.verdict}' onto parent ${parentId.slice(0, 8)} checklist`);
+          }
+        } catch {
+        }
         logger.log(`[supervision] verdict '${v.verdict}' for ${v.sessionId.slice(0, 8)} \u2192 parent ${parentId.slice(0, 8)}`);
       } catch {
       }
@@ -10668,6 +11435,8 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
             metadata = {
               flavor: m.flavor,
               name: m.name,
+              friendlyName: m.friendlyName,
+              projectName: m.projectName,
               path: m.path,
               host: m.host,
               lifecycleState: m.lifecycleState,
@@ -10689,6 +11458,24 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
         };
       });
     };
+    const collectKnownFriendlyNames = () => {
+      const taken = /* @__PURE__ */ new Set();
+      for (const s of pidToTrackedSession.values()) {
+        try {
+          const fn = s.hyphaService?.getMetadata?.()?.friendlyName;
+          if (fn) taken.add(fn);
+        } catch {
+        }
+      }
+      try {
+        for (const p of loadPersistedSessions()) {
+          const fn = p.metadata?.friendlyName;
+          if (fn) taken.add(fn);
+        }
+      } catch {
+      }
+      return taken;
+    };
     let machineServiceRef = null;
     const spawnSession = async (options2) => {
       logger.log("Spawning session:", JSON.stringify(options2));
@@ -10807,6 +11594,8 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
         var parseBashPermission = parseBashPermission2, shouldAutoAllow = shouldAutoAllow2, killAndWaitForExit = killAndWaitForExit2, buildIsolationConfig = buildIsolationConfig2;
         let sessionMetadata = {
           path: directory,
+          // Project namespace for the friendly handle (folder/repo basename).
+          projectName: projectName(directory),
           host: os$1.hostname(),
           version: "0.1.0",
           machineId,
@@ -10833,6 +11622,10 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
         const allPersisted = loadPersistedSessions();
         const persisted = allPersisted.find((p) => p.sessionId === sessionId) || (resumeSessionId ? allPersisted.find((p) => p.claudeResumeId === resumeSessionId) : void 0);
         let claudeResumeId = persisted?.claudeResumeId || (resumeSessionId || void 0);
+        sessionMetadata = {
+          ...sessionMetadata,
+          friendlyName: persisted?.metadata?.friendlyName || generateFriendlyName(collectKnownFriendlyNames())
+        };
         let currentPermissionMode = options2.permissionMode || persisted?.permissionMode || "bypassPermissions";
         const sessionCreatedAt = persisted?.createdAt || Date.now();
         let lastSpawnMeta = persisted?.spawnMeta || {};
@@ -11117,7 +11910,7 @@ ${parts.join("\n")}`);
           const permissionMode = toClaudePermissionMode(rawPermissionMode);
           currentPermissionMode = permissionMode;
           const model = effectiveMeta.model || agentConfig.default_model || void 0;
-          const appendSystemPrompt = effectiveMeta.appendSystemPrompt || agentConfig.append_system_prompt || buildBaselineSystemPrompt(sessionId);
+          const appendSystemPrompt = effectiveMeta.appendSystemPrompt || agentConfig.append_system_prompt || buildBaselineSystemPrompt(sessionId, formatHandle(sessionMetadata.projectName, sessionMetadata.friendlyName));
           const args = [
             "--output-format",
             "stream-json",
@@ -11179,6 +11972,10 @@ ${parts.join("\n")}`);
           let spawnEnv = { ...process.env, ...extraEnv };
           delete spawnEnv.CLAUDECODE;
           spawnEnv.SVAMP_SESSION_ID = sessionId;
+          {
+            const handle = formatHandle(sessionMetadata.projectName, sessionMetadata.friendlyName);
+            if (handle) spawnEnv.SVAMP_SESSION_HANDLE = handle;
+          }
           delete spawnEnv.SVAMP_SANDBOXED;
           const proxyDesc = applyClaudeProxyEnv(spawnEnv);
           if (proxyDesc) {
@@ -11673,12 +12470,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;
@@ -11690,6 +12488,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 {
@@ -11702,6 +12508,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`);
@@ -11715,6 +12524,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);
@@ -11735,6 +12564,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 {
@@ -11954,6 +12784,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 };
@@ -12333,8 +13243,12 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           return false;
         };
         var parseBashPermission = parseBashPermission2, shouldAutoAllow = shouldAutoAllow2;
+        const acpPersistedName = loadPersistedSessions().find((p) => p.sessionId === sessionId)?.metadata?.friendlyName;
         let sessionMetadata = {
           path: directory,
+          // Project namespace for the friendly handle (folder/repo basename).
+          projectName: projectName(directory),
+          friendlyName: acpPersistedName || generateFriendlyName(collectKnownFriendlyNames()),
           host: os$1.hostname(),
           version: "0.1.0",
           machineId,
@@ -13108,7 +14022,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-CdcXdQde.mjs');
+      const { FrpcTunnel } = await import('./frpc-DRWpAeZW.mjs');
       for (const spec of specs) {
         if (tunnels.has(spec.name)) continue;
         try {
@@ -13884,4 +14798,4 @@ var run = /*#__PURE__*/Object.freeze({
     writeStopMarker: writeStopMarker
 });
 
-export { api as $, READ_ONLY_TOOLS as A, loadMachineContext as B, buildMachineInstructions as C, machineToolsForRole as D, buildMachineTools as E, resolveModel as F, normalizeAllowedUser as G, loadSecurityContextConfig as H, resolveSecurityContext as I, buildSecurityContextFromFlags as J, mergeSecurityContexts as K, buildSessionShareUrl as L, computeOutboundHop as M, buildMachineShareUrl as N, describeMisconfiguration as O, buildMachineDeps as P, generateHookSettings as Q, RoutineStore as R, ServeAuth as S, projectInfo as T, DefaultTransport$1 as U, acpBackend as V, acpAgentConfig as W, codexMcpBackend as X, GeminiTransport$1 as Y, claudeAuth as Z, instanceConfig as _, createSessionStore as a, run as a0, stopDaemon as b, connectToHypha as c, daemonStatus as d, clearStopMarker as e, stopMarkerExists as f, getHyphaServerUrl$1 as g, getFrpsSubdomainHost as h, getFrpsServerPort as i, getFrpsServerAddr as j, getHyphaServerUrl as k, hasCookieToken as l, RoutineRunner as m, shortId as n, getSkillsServer as o, parseFrontmatter as p, getSkillsWorkspaceName as q, registerMachineService as r, startDaemon as s, getSkillsCollectionName as t, fetchWithTimeout as u, searchSkills as v, SKILLS_DIR as w, getSkillInfo as x, downloadSkillFile as y, listSkillFiles as z };
+export { GeminiTransport$1 as $, READ_ONLY_TOOLS as A, loadMachineContext as B, buildMachineInstructions as C, machineToolsForRole as D, buildMachineTools as E, resolveModel as F, formatHandle as G, normalizeAllowedUser as H, loadSecurityContextConfig as I, resolveSecurityContext as J, buildSecurityContextFromFlags as K, mergeSecurityContexts as L, buildSessionShareUrl as M, computeOutboundHop as N, buildMachineShareUrl as O, parseHandle as P, handleMatchesMetadata as Q, RoutineStore as R, ServeAuth as S, describeMisconfiguration as T, buildMachineDeps as U, generateHookSettings as V, projectInfo as W, DefaultTransport$1 as X, acpBackend as Y, acpAgentConfig as Z, codexMcpBackend as _, createSessionStore as a, claudeAuth as a0, instanceConfig as a1, api as a2, run as a3, stopDaemon as b, connectToHypha as c, daemonStatus as d, clearStopMarker as e, stopMarkerExists as f, getHyphaServerUrl$1 as g, getFrpsSubdomainHost as h, getFrpsServerPort as i, getFrpsServerAddr as j, getHyphaServerUrl as k, hasCookieToken as l, RoutineRunner as m, shortId as n, getSkillsServer as o, parseFrontmatter as p, getSkillsWorkspaceName as q, registerMachineService as r, startDaemon as s, getSkillsCollectionName as t, fetchWithTimeout as u, searchSkills as v, SKILLS_DIR as w, getSkillInfo as x, downloadSkillFile as y, listSkillFiles as z };