svamp-cli 0.2.115 → 0.2.116

package/dist/{run-DXzaCfex.mjs → run-DHPCWQUq.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, 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 { 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 { 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-1aSnPVrE.mjs');
+        const { FrpcTunnel } = await import('./frpc-9qgaimIN.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-vimBRRDF.mjs');
+          const { toolsForRole } = await import('./sideband-CYNK4foC.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-B3NhziMR.mjs');
+    const { queryCore } = await import('./commands-DdW5M7Le.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3479,48 +3479,6 @@ 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;
@@ -3666,100 +3624,6 @@ 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) => {
@@ -4439,72 +4303,59 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       if (!claudeSessionId) {
         return { success: false, error: "No active Claude session to query" };
       }
-      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 { 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 store = {
@@ -7338,171 +7189,6 @@ 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");
@@ -10234,7 +9920,15 @@ function deactivateLoop(directory, sessionId) {
   } catch {
   }
 }
-function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata, sessionService, logger, onLoopActivated) {
+function readLoopJson(directory, sessionId, file) {
+  try {
+    const p = join$1(getLoopDir(directory, sessionId), file);
+    return existsSync$1(p) ? JSON.parse(readFileSync$1(p, "utf-8")) : null;
+  } catch {
+    return null;
+  }
+}
+function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata, sessionService, logger, onLoopActivated, onSupervisionVerdict) {
   const configPath = getSvampConfigPath(directory, sessionId);
   let lastConfigContent = "";
   if (existsSync$1(configPath)) {
@@ -10323,6 +10017,27 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         "event"
       );
       logger.log(`[svampConfig] ${s.phase === "done" ? "Loop complete" : "Loop gave up"} (iter ${iter})`);
+      try {
+        const cfg = readLoopJson(directory, sessionId, "loop.config.json") || {};
+        const ev = readLoopJson(directory, sessionId, "evaluator-verdict.json") || {};
+        const verdict = {
+          type: "supervision:verdict",
+          sessionId,
+          round: iter,
+          verdict: s.phase === "done" ? "approved" : "rework",
+          criteria: typeof cfg.criteria === "string" ? cfg.criteria : "",
+          judge: cfg.evaluator?.enabled !== false ? "agent" : cfg.oracle ? "oracle" : "agent",
+          ...s.phase === "gave_up" ? { guidance: s.gave_up_reason || "gave up before meeting the criteria" } : ev.guidance ? { guidance: String(ev.guidance) } : {},
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        try {
+          const vp = join$1(getLoopDir(directory, sessionId), "supervisor-verdict.json");
+          writeFileSync$1(vp, JSON.stringify(verdict, null, 2));
+        } catch {
+        }
+        onSupervisionVerdict?.(verdict);
+      } catch {
+      }
     } catch {
     }
   };
@@ -10378,6 +10093,53 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
       const { loop: _, ...restPatch } = patch;
       patch = restPatch;
     }
+    if ("supervisor" in patch) {
+      const sup = patch.supervisor;
+      if (sup && typeof sup === "object" && typeof sup.criteria === "string" && sup.criteria.trim()) {
+        const criteria = sup.criteria.trim();
+        const judges = Array.isArray(sup.judges) ? sup.judges : [];
+        const oracleJudge = judges.find((j) => j?.type === "oracle");
+        const oracle = oracleJudge && typeof oracleJudge.cmd === "string" && oracleJudge.cmd.trim() ? oracleJudge.cmd.trim() : typeof sup.oracle === "string" && sup.oracle.trim() ? sup.oracle.trim() : void 0;
+        const hasAgentJudge = judges.length === 0 || judges.some((j) => j?.type === "agent");
+        const maxRounds = typeof sup.max_rounds === "number" ? sup.max_rounds : 20;
+        const ok = initLoop(directory, {
+          task: criteria,
+          // P1: criteria seeds LOOP.md as the goal (skill carries it as config.criteria in #30)
+          criteria,
+          oracle,
+          maxIterations: maxRounds,
+          evaluator: hasAgentJudge,
+          sessionId
+        });
+        if (ok) {
+          const judgeLabel = judges.length ? judges.map((j) => j.type).join("\u2192") : "agent";
+          const idle = getMetadata().lifecycleState === "idle";
+          if (idle) {
+            const existingQueue = getMetadata().messageQueue || [];
+            const nudge = `You are now under supervision. Success criteria: ${criteria}
+Continue working until they are met, or verify and finish \u2014 an independent Stop gate will re-check before you can stop.`;
+            setMetadata((m) => ({ ...m, messageQueue: [...existingQueue, { id: randomUUID$1(), text: nudge, displayText: `\u{1F441} Supervisor attached`, createdAt: Date.now() }] }));
+            onLoopActivated?.();
+          }
+          sessionService.pushMessage(
+            { type: "message", message: `\u{1F441} Supervisor attached \u2014 judges: ${judgeLabel}, max ${maxRounds}. Criteria: ${criteria.slice(0, 120)}${criteria.length > 120 ? "\u2026" : ""}` },
+            "event"
+          );
+          logger.log(`[svampConfig] Supervisor attached (judges: ${judgeLabel}, max ${maxRounds})`);
+        } else {
+          sessionService.pushMessage(
+            { type: "message", message: "Failed to attach supervisor \u2014 the loop skill could not be located. Reinstall with: svamp skills install loop --force", level: "error" },
+            "event"
+          );
+        }
+      } else {
+        deactivateLoop(directory, sessionId);
+        sessionService.pushMessage({ type: "message", message: "Supervisor detached." }, "event");
+        logger.log(`[svampConfig] Supervisor detached`);
+      }
+      const { supervisor: _s, ...restPatch } = patch;
+      patch = restPatch;
+    }
     if (Object.keys(patch).length > 0) {
       const config = readSvampConfig(configPath);
       for (const [key, value] of Object.entries(patch)) {
@@ -10805,7 +10567,7 @@ async function startDaemon(options) {
     const list = loadExposedTunnels().filter((t) => t.name !== name);
     saveExposedTunnels(list);
   }
-  const { ServeManager } = await import('./serveManager-BnwAe-VX.mjs');
+  const { ServeManager } = await import('./serveManager-B19qVJeZ.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -10835,6 +10597,31 @@ async function startDaemon(options) {
       logger.log(`Hypha connection permanently lost: ${reason}. Daemon continues running \u2014 restart manually to reconnect.`);
     });
     const pidToTrackedSession = /* @__PURE__ */ new Map();
+    const routeSupervisionVerdict = (parentId, v) => {
+      try {
+        if (!parentId) return;
+        const parent = Array.from(pidToTrackedSession.values()).find((t) => t.svampSessionId === parentId);
+        const send = parent?.sessionRPCHandlers?.sendInboxMessage;
+        if (!send) return;
+        Promise.resolve(send({
+          messageId: randomUUID$1(),
+          from: `agent:${v.sessionId}`,
+          fromSession: v.sessionId,
+          to: parentId,
+          subject: `supervision: ${v.verdict} (child ${v.sessionId.slice(0, 8)})`,
+          body: `<supervision-verdict child="${v.sessionId}" verdict="${v.verdict}" round="${v.round}" judge="${v.judge}">
+${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
+</supervision-verdict>`,
+          timestamp: Date.now(),
+          read: false,
+          urgency: "normal",
+          hopCount: 1
+        })).catch(() => {
+        });
+        logger.log(`[supervision] verdict '${v.verdict}' for ${v.sessionId.slice(0, 8)} \u2192 parent ${parentId.slice(0, 8)}`);
+      } catch {
+      }
+    };
     server.on("services_registered", () => {
       if (consecutiveHeartbeatFailures > 0) {
         logger.log(`Hypha reconnection successful \u2014 services re-registered (resetting ${consecutiveHeartbeatFailures} failures)`);
@@ -11857,13 +11644,12 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           }
           return child;
         };
-        const restartClaudeHandler = async (opts) => {
+        const restartClaudeHandler = async () => {
           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;
@@ -11875,14 +11661,6 @@ ${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 {
@@ -11895,9 +11673,6 @@ ${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`);
@@ -11911,26 +11686,6 @@ ${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);
@@ -11951,7 +11706,6 @@ ${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 {
@@ -12171,86 +11925,6 @@ ${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 };
@@ -12511,7 +12185,8 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           logger,
           () => {
             if (!trackedSession?.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
-          }
+          },
+          (v) => routeSupervisionVerdict(sessionMetadata.parentSessionId, v)
         );
         checkSvampConfig = svampConfig.check;
         cleanupSvampConfig = svampConfig.cleanup;
@@ -13008,7 +12683,8 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 }
               });
             }
-          }
+          },
+          (v) => routeSupervisionVerdict(sessionMetadata.parentSessionId, v)
         );
         const checkSvampConfig = svampConfigChecker.check;
         const writeSvampConfigPatchAcp = svampConfigChecker.writeConfig;
@@ -13403,7 +13079,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-1aSnPVrE.mjs');
+      const { FrpcTunnel } = await import('./frpc-9qgaimIN.mjs');
       for (const spec of specs) {
         if (tunnels.has(spec.name)) continue;
         try {