svamp-cli 0.2.98 → 0.2.101

package/dist/{run-DxzG-3JD.mjs → run-CsMTSngP.mjs}

@@ -3,7 +3,7 @@ import fs, { mkdir as mkdir$1, readdir as readdir$1, readFile, writeFile as writ
 import { readFileSync as readFileSync$1, mkdirSync, writeFileSync, renameSync, existsSync as existsSync$1, rmSync as rmSync$1, unlinkSync as unlinkSync$1, copyFileSync, watch, rmdirSync, readdirSync as readdirSync$1 } from 'fs';
 import path__default, { join, dirname, basename, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import { execFile, spawn as spawn$1, execSync as execSync$1 } from 'child_process';
+import { execFile, spawn as spawn$1, execSync as execSync$1, spawnSync } from 'child_process';
 import { randomUUID as randomUUID$1 } from 'crypto';
 import { existsSync, readFileSync, mkdirSync as mkdirSync$1, readdirSync, writeFileSync as writeFileSync$1, renameSync as renameSync$1, rmSync, appendFileSync, unlinkSync } from 'node:fs';
 import { exec, spawn, execSync, execFile as execFile$1, execFileSync } from 'node:child_process';
@@ -433,6 +433,75 @@ function buildTools(deps, skills) {
         }
         return "(sent to the coding agent)";
       }
+    },
+    // Create routine / loop / channel. ONLY call after the caller confirmed the
+    // proposed config (see the propose-then-confirm instruction in context.ts).
+    {
+      name: "create_routine",
+      readOnly: false,
+      description: "Create a session-scoped routine (cron schedule or webhook \u2192 message or loop). ONLY after the caller confirmed the proposal.",
+      parameters: { type: "object", properties: {
+        name: { type: "string", description: "Short human name." },
+        cron: { type: "string", description: 'Cron for a schedule trigger, e.g. "0 9 * * 1-5". Omit for a webhook.' },
+        tz: { type: "string", description: "IANA timezone for the schedule." },
+        action_kind: { type: "string", enum: ["message", "loop"], description: '"message" sends text to this session; "loop" starts a self-verifying loop.' },
+        message: { type: "string", description: "For message action: the text/template to deliver." },
+        task: { type: "string", description: "For loop action: the loop task." },
+        oracle: { type: "string", description: "For loop action: optional pass/fail command." }
+      }, required: ["name", "action_kind"], additionalProperties: false },
+      run: async (a) => {
+        const cron = a?.cron ? str$1(a.cron) : "";
+        const routine = {
+          name: str$1(a?.name),
+          enabled: true,
+          trigger: cron ? { type: "schedule", cron, ...a?.tz ? { tz: str$1(a.tz) } : {} } : { type: "webhook" },
+          action: str$1(a?.action_kind) === "loop" ? { kind: "loop", task_template: str$1(a?.task), loop: { task: str$1(a?.task), ...a?.oracle ? { oracle: str$1(a.oracle) } : {} } } : { kind: "message", template: str$1(a?.message) }
+        };
+        const r = await deps.saveRoutine(routine);
+        return r.success ? `Created routine "${str$1(a?.name)}" (${r.routine?.id || "saved"}).` : `Could not create routine: ${r.error || "unknown error"}.`;
+      }
+    },
+    {
+      name: "create_loop",
+      readOnly: false,
+      description: "Start a self-verifying loop in the bound session (iterates until an evaluator + optional oracle confirm done). ONLY after the caller confirmed the proposal.",
+      parameters: { type: "object", properties: {
+        task: { type: "string", description: "What the loop should accomplish." },
+        criteria: { type: "string", description: "How we know it is genuinely done." },
+        oracle: { type: "string", description: 'Optional pass/fail command (e.g. "npm test").' },
+        max_iterations: { type: "number", description: "Iteration ceiling (default 20)." }
+      }, required: ["task"], additionalProperties: false },
+      run: async (a) => {
+        await deps.startLoop({
+          task: str$1(a?.task),
+          criteria: a?.criteria ? str$1(a.criteria) : void 0,
+          oracle: a?.oracle ? str$1(a.oracle) : void 0,
+          maxIterations: typeof a?.max_iterations === "number" ? a.max_iterations : void 0
+        });
+        return `Started a loop: "${str$1(a?.task).slice(0, 80)}".`;
+      }
+    },
+    {
+      name: "create_channel",
+      readOnly: false,
+      description: "Create an inbound channel so other users/agents can message this session (identity-tagged). ONLY after the caller confirmed the proposal.",
+      parameters: { type: "object", properties: {
+        name: { type: "string", description: "Short channel name." },
+        description: { type: "string", description: "What this channel is for." },
+        identity_mode: { type: "string", enum: ["per-key", "caller-supplied", "fixed"], description: 'How callers are identified (default "per-key").' }
+      }, required: ["name"], additionalProperties: false },
+      run: async (a) => {
+        const mode = a?.identity_mode ? str$1(a.identity_mode) : "per-key";
+        const channel = {
+          name: str$1(a?.name),
+          ...a?.description ? { description: str$1(a.description) } : {},
+          enabled: true,
+          identity: mode === "fixed" ? { mode, fixed: { name: "caller", kind: "agent" } } : { mode },
+          action: { kind: "message" }
+        };
+        const r = await deps.saveChannel(channel);
+        return r.success ? `Created channel "${str$1(a?.name)}" (${r.channel?.id || "saved"}).` : `Could not create channel: ${r.error || "unknown error"}.`;
+      }
     }
   ];
 }
@@ -560,10 +629,12 @@ You are WISE Agent, a fast, text-mode companion to the deep coding agent (Claude
 - use_skill \u2014 load a project skill's full steps by name, then carry them out with run_bash.
 - run_bash \u2014 run a shell command on the session's machine (when granted).
 - send_to_session \u2014 hand a clear, reformulated instruction to the deep coding agent (when granted); pass wait=true to block for its reply.
+- create_routine / create_loop / create_channel \u2014 set up a scheduled/triggered routine, a self-verifying loop, or an inbound channel for this session (when granted). ALWAYS propose first and confirm before calling these (see below).
 
 # Instructions
 - Answer general questions and questions about yourself directly. Use tools only to act on the machine/session.
 - Take the cheap path: read state directly; delegate anything LONG to summarize_session \u2014 keep your own context small.
+- To create a routine, loop, or channel: first restate the resolved config in one line and ask the caller to reply "confirm" to proceed. Only call create_routine / create_loop / create_channel after they confirm in a follow-up message. Never create without confirmation.
 - For destructive actions (deleting, stopping, killing), require a verified caller and confirm intent; for safe reads, just do it.
 - If a tool fails or returns nothing useful, say so plainly \u2014 never fabricate a result.
 - Report the outcome in one line.`;
@@ -936,6 +1007,23 @@ function buildSessionDeps(rpc, opts = {}) {
         recentMessageCount: messages.length,
         latestMessage: latestText
       };
+    },
+    async saveRoutine(routine) {
+      return await rpc.saveRoutine(routine, ctx);
+    },
+    async startLoop(cfg) {
+      await rpc.updateConfig({
+        loop: {
+          task: cfg.task,
+          ...cfg.criteria ? { criteria: cfg.criteria } : {},
+          ...cfg.oracle ? { oracle: cfg.oracle } : {},
+          max_iterations: cfg.maxIterations ?? 20,
+          evaluator: true
+        }
+      }, ctx);
+    },
+    async saveChannel(channel) {
+      return await rpc.saveChannel(channel, ctx);
     }
   };
 }
@@ -2077,7 +2165,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-BZ4l4-os.mjs');
+        const { FrpcTunnel } = await import('./frpc-WVnBbyjf.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -2338,7 +2426,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-wPe3a3m1.mjs');
+          const { toolsForRole } = await import('./sideband-C10Ni7p_.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3319,7 +3407,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     },
     /**
      * Patch the session config file (.svamp/{sessionId}/config.json).
-     * Used by the frontend to set title, session_link, ralph_loop, etc.
+     * Used by the frontend to set title, session_link, loop activation, etc.
      * Null values remove keys from the config.
      */
     updateConfig: async (patch, context) => {
@@ -9095,6 +9183,20 @@ async function ensureAutoInstalledSkills(logger) {
         }
       },
       marketplaceVersion: async () => readBundledSkillVersion("artifact")
+    },
+    {
+      // The self-verifying `loop` skill drives loop mode (Stop-hook gate +
+      // LOOP.md injection). Bundled in the npm package (bin/skills/loop/) so the
+      // daemon can run loop-init.mjs even offline / before marketplace publish.
+      name: "loop",
+      install: async () => {
+        try {
+          installBundledSkill("loop");
+        } catch {
+          await installSkillFromMarketplace("loop");
+        }
+      },
+      marketplaceVersion: async () => readBundledSkillVersion("loop")
     }
   ];
   for (const task of tasks) {
@@ -9224,72 +9326,58 @@ function writeSvampConfig(configPath, config) {
   renameSync(tmpPath, configPath);
   return content;
 }
-function getRalphStateFilePath(directory, sessionId) {
-  return join(getSessionDir(directory, sessionId), "ralph-loop.md");
+function getLoopDir(directory) {
+  return join(directory, ".claude", "loop");
 }
-function readRalphState(filePath) {
+function readLoopState(directory) {
   try {
-    if (!existsSync$1(filePath)) return null;
-    const content = readFileSync$1(filePath, "utf-8");
-    const parts = content.split(/^---$/m);
-    if (parts.length < 3) return null;
-    const frontmatter = parts[1];
-    const task = parts.slice(2).join("---").trim();
-    if (!task) return null;
-    const fields = {};
-    for (const line of frontmatter.split("\n")) {
-      const match = line.match(/^(\w+):\s*(.*)$/);
-      if (match) fields[match[1]] = match[2].replace(/^["']|["']$/g, "");
-    }
-    return {
-      iteration: parseInt(fields.iteration || "1", 10) || 1,
-      max_iterations: parseInt(fields.max_iterations || "0", 10) || 0,
-      completion_promise: fields.completion_promise === "none" ? null : fields.completion_promise || "DONE",
-      cooldown_seconds: parseInt(fields.cooldown_seconds || "1", 10) || 1,
-      started_at: fields.started_at || (/* @__PURE__ */ new Date()).toISOString(),
-      last_iteration_at: fields.last_iteration_at || void 0,
-      context_mode: fields.context_mode === "fresh" || fields.context_mode === "continue" ? fields.context_mode : void 0,
-      original_resume_id: fields.original_resume_id || void 0,
-      task
-    };
+    const p = join(getLoopDir(directory), "loop-state.json");
+    if (!existsSync$1(p)) return null;
+    return JSON.parse(readFileSync$1(p, "utf-8"));
   } catch {
     return null;
   }
 }
-function writeRalphState(filePath, state) {
-  mkdirSync(dirname(filePath), { recursive: true });
-  const promiseYaml = state.completion_promise === null ? "none" : state.completion_promise.includes(":") || state.completion_promise.includes('"') ? `"${state.completion_promise.replace(/"/g, '\\"')}"` : `"${state.completion_promise}"`;
-  const lastIterLine = state.last_iteration_at ? `
-last_iteration_at: "${state.last_iteration_at}"` : "";
-  const contextModeLine = state.context_mode ? `
-context_mode: "${state.context_mode}"` : "";
-  const originalResumeLine = state.original_resume_id ? `
-original_resume_id: "${state.original_resume_id}"` : "";
-  const content = `---
-iteration: ${state.iteration}
-max_iterations: ${state.max_iterations}
-completion_promise: ${promiseYaml}
-cooldown_seconds: ${state.cooldown_seconds}
-started_at: "${state.started_at}"${lastIterLine}${contextModeLine}${originalResumeLine}
----
-
-${state.task}
-`;
-  const tmpPath = `${filePath}.tmp`;
-  writeFileSync(tmpPath, content);
-  renameSync(tmpPath, filePath);
+function isLoopActive(directory) {
+  const s = readLoopState(directory);
+  return !!s && s.active !== false && s.phase !== "done" && s.phase !== "gave_up" && s.phase !== "cancelled";
+}
+function resolveLoopInit() {
+  const candidates = [
+    join(CLAUDE_SKILLS_DIR, "loop", "bin", "loop-init.mjs"),
+    ...getBundledSkillsDir() ? [join(getBundledSkillsDir(), "loop", "bin", "loop-init.mjs")] : []
+  ];
+  for (const c of candidates) if (existsSync$1(c)) return c;
+  return null;
 }
-function removeRalphState(filePath) {
+function initLoop(directory, cfg) {
+  const initScript = resolveLoopInit();
+  if (!initScript) return false;
+  const args = [initScript, directory, "--task", cfg.task];
+  if (cfg.criteria) args.push("--criteria", cfg.criteria);
+  if (cfg.oracle) args.push("--oracle", cfg.oracle);
+  if (typeof cfg.maxIterations === "number") args.push("--max", String(cfg.maxIterations));
+  args.push("--evaluator", cfg.evaluator === false ? "off" : "on");
+  if (cfg.model) args.push("--model", cfg.model);
+  const res = spawnSync(process.execPath, args, { encoding: "utf-8", timeout: 3e4 });
+  return res.status === 0;
+}
+function deactivateLoop(directory) {
   try {
-    unlinkSync$1(filePath);
+    const p = join(getLoopDir(directory), "loop-state.json");
+    if (!existsSync$1(p)) return;
+    const s = JSON.parse(readFileSync$1(p, "utf-8"));
+    s.active = false;
+    s.phase = "cancelled";
+    const tmp = p + ".tmp";
+    writeFileSync(tmp, JSON.stringify(s, null, 2));
+    renameSync(tmp, p);
   } catch {
   }
 }
-function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata, sessionService, logger, onRalphLoopActivated) {
+function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata, sessionService, logger, onLoopActivated) {
   const configPath = getSvampConfigPath(directory, sessionId);
-  const ralphStatePath = getRalphStateFilePath(directory, sessionId);
   let lastConfigContent = "";
-  let lastRalphContent = "";
   if (existsSync$1(configPath)) {
     try {
       lastConfigContent = readFileSync$1(configPath, "utf-8");
@@ -9300,13 +9388,6 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
     } catch {
     }
   }
-  if (existsSync$1(ralphStatePath)) {
-    try {
-      lastRalphContent = readFileSync$1(ralphStatePath, "utf-8");
-    } catch {
-    }
-  }
-  let needsInitialRalphProcess = !!lastRalphContent;
   function processConfig(config, meta) {
     if (typeof config.title === "string" && config.title.trim()) {
       const newTitle = config.title.trim();
@@ -9351,56 +9432,6 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
       }
     }
   }
-  function processRalphState() {
-    const meta = getMetadata();
-    const prevRalph = meta.ralphLoop;
-    const state = readRalphState(ralphStatePath);
-    if (state) {
-      const ralphLoop = {
-        active: true,
-        task: state.task,
-        completionPromise: state.completion_promise ?? "none",
-        maxIterations: state.max_iterations,
-        currentIteration: state.iteration,
-        startedAt: state.started_at,
-        cooldownSeconds: state.cooldown_seconds,
-        contextMode: state.context_mode || "fresh",
-        lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      if (!prevRalph?.active) {
-        const progressRelPath = `.svamp/${sessionId}/ralph-progress.md`;
-        const prompt = buildRalphPrompt(state.task, state);
-        const ralphSysPrompt = buildRalphSystemPrompt(state, progressRelPath);
-        const existingQueue = getMetadata().messageQueue || [];
-        setMetadata((m) => ({
-          ...m,
-          ralphLoop,
-          messageQueue: [...existingQueue, {
-            id: randomUUID$1(),
-            text: prompt,
-            displayText: state.task,
-            createdAt: Date.now(),
-            ralphSystemPrompt: ralphSysPrompt
-          }]
-        }));
-        sessionService.pushMessage(
-          { type: "message", message: buildIterationStatus(state.iteration + 1, state.max_iterations, state.completion_promise) },
-          "event"
-        );
-        logger.log(`[svampConfig] Ralph loop started/resumed at iteration ${state.iteration + 1}: "${state.task.slice(0, 50)}..."`);
-        onRalphLoopActivated?.();
-      } else if (prevRalph.currentIteration !== ralphLoop.currentIteration || prevRalph.task !== ralphLoop.task) {
-        setMetadata((m) => ({ ...m, ralphLoop }));
-      }
-    } else if (prevRalph?.active) {
-      setMetadata((m) => ({ ...m, ralphLoop: { active: false } }));
-      sessionService.pushMessage(
-        { type: "message", message: `Ralph loop cancelled at iteration ${prevRalph.currentIteration}.` },
-        "event"
-      );
-      logger.log(`[svampConfig] Ralph loop state file removed \u2014 cancelled at iteration ${prevRalph.currentIteration}`);
-    }
-  }
   const configChecker = () => {
     try {
       if (existsSync$1(configPath)) {
@@ -9414,50 +9445,54 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
     } catch {
     }
   };
-  const ralphChecker = () => {
-    try {
-      if (existsSync$1(ralphStatePath)) {
-        const content = readFileSync$1(ralphStatePath, "utf-8");
-        if (content !== lastRalphContent) {
-          lastRalphContent = content;
-          processRalphState();
-        }
-      } else if (lastRalphContent) {
-        lastRalphContent = "";
-        processRalphState();
-      }
-    } catch {
-    }
-  };
   const checker = () => {
     configChecker();
-    ralphChecker();
   };
   const writeConfig = (patch) => {
-    if ("ralph_loop" in patch) {
-      const rl = patch.ralph_loop;
-      if (rl && typeof rl === "object" && typeof rl.task === "string") {
-        const contextMode = rl.context_mode === "fresh" || rl.context_mode === "continue" ? rl.context_mode : void 0;
-        writeRalphState(ralphStatePath, {
-          iteration: typeof rl.current_iteration === "number" ? Math.max(0, rl.current_iteration - 1) : 0,
-          max_iterations: typeof rl.max_iterations === "number" ? rl.max_iterations : 0,
-          completion_promise: rl.completion_promise === "none" || rl.completion_promise === null ? null : rl.completion_promise || "DONE",
-          cooldown_seconds: (() => {
-            const cd = typeof rl.cooldown_seconds === "number" ? rl.cooldown_seconds : 1;
-            const isInfinite = !rl.completion_promise || rl.completion_promise === "none";
-            return isInfinite ? Math.max(1, cd) : cd;
-          })(),
-          started_at: rl.started_at || (/* @__PURE__ */ new Date()).toISOString(),
-          context_mode: contextMode,
-          task: rl.task.trim()
+    if ("loop" in patch) {
+      const lp = patch.loop;
+      if (lp && typeof lp === "object" && typeof lp.task === "string" && lp.task.trim()) {
+        const oracle = typeof lp.oracle === "string" && lp.oracle.trim() ? lp.oracle.trim() : void 0;
+        const maxIterations = typeof lp.max_iterations === "number" ? lp.max_iterations : 20;
+        const evaluator = lp.evaluator !== false;
+        const ok = initLoop(directory, {
+          task: lp.task.trim(),
+          criteria: typeof lp.criteria === "string" && lp.criteria.trim() ? lp.criteria.trim() : void 0,
+          oracle,
+          maxIterations,
+          evaluator
         });
-        ralphChecker();
+        if (ok) {
+          const existingQueue = getMetadata().messageQueue || [];
+          const kickoff = "Begin the loop. Read LOOP.md and work on the task until the exit conditions are met. Do not stop early \u2014 an independent Stop gate will re-check before the loop can end.";
+          setMetadata((m) => ({
+            ...m,
+            messageQueue: [...existingQueue, {
+              id: randomUUID$1(),
+              text: kickoff,
+              displayText: `\u{1F501} Loop started: ${lp.task.trim().slice(0, 100)}`,
+              createdAt: Date.now()
+            }]
+          }));
+          sessionService.pushMessage(
+            { type: "message", message: `\u{1F501} Loop started \u2014 iterating until done (oracle: ${oracle || "none"}, evaluator ${evaluator ? "on" : "off"}, max ${maxIterations}).` },
+            "event"
+          );
+          logger.log(`[svampConfig] Loop started: "${lp.task.trim().slice(0, 50)}..."`);
+          onLoopActivated?.();
+        } else {
+          sessionService.pushMessage(
+            { type: "message", message: "Failed to start loop \u2014 the loop skill could not be located. Reinstall with: svamp skills install loop --force", level: "error" },
+            "event"
+          );
+          logger.log(`[svampConfig] Loop init failed \u2014 loop-init.mjs not found`);
+        }
       } else {
-        removeRalphState(ralphStatePath);
-        lastRalphContent = "";
-        processRalphState();
+        deactivateLoop(directory);
+        sessionService.pushMessage({ type: "message", message: "Loop cancelled." }, "event");
+        logger.log(`[svampConfig] Loop cancelled`);
       }
-      const { ralph_loop: _, ...restPatch } = patch;
+      const { loop: _, ...restPatch } = patch;
       patch = restPatch;
     }
     if (Object.keys(patch).length > 0) {
@@ -9476,32 +9511,11 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
     mkdirSync(configDir, { recursive: true });
     watcher = watch(configDir, (eventType, filename) => {
       if (filename === "config.json") configChecker();
-      if (filename === "ralph-loop.md") ralphChecker();
     });
     watcher.on("error", () => {
     });
   } catch {
   }
-  if (needsInitialRalphProcess) {
-    const state = readRalphState(ralphStatePath);
-    if (state) {
-      setMetadata((m) => ({
-        ...m,
-        ralphLoop: {
-          active: true,
-          task: state.task,
-          completionPromise: state.completion_promise ?? "none",
-          maxIterations: state.max_iterations,
-          currentIteration: state.iteration,
-          startedAt: state.started_at,
-          cooldownSeconds: state.cooldown_seconds,
-          contextMode: state.context_mode || "fresh",
-          lastIterationStartedAt: state.last_iteration_at || (/* @__PURE__ */ new Date()).toISOString()
-        }
-      }));
-      logger.log(`[svampConfig] Ralph loop state restored (iteration ${state.iteration}): "${state.task.slice(0, 50)}..."`);
-    }
-  }
   return {
     check: checker,
     cleanup: () => {
@@ -9510,133 +9524,6 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
     writeConfig
   };
 }
-function buildIterationStatus(iteration, maxIterations, completionPromise) {
-  const iterStr = maxIterations > 0 ? `${iteration}/${maxIterations}` : `${iteration}`;
-  if (completionPromise) {
-    return `Ralph iteration ${iterStr} | To stop: output <promise>${completionPromise}</promise>`;
-  }
-  return `Ralph iteration ${iterStr} | Manual stop only`;
-}
-function buildRalphSystemPrompt(state, progressFilePath) {
-  const isFresh = state.context_mode === "fresh" || !state.context_mode;
-  if (isFresh && progressFilePath) {
-    return [
-      "# Ralph Loop \u2014 Fresh Context Mode",
-      "",
-      "You are an autonomous coding agent in an automated loop.",
-      "Each iteration spawns a fresh process \u2014 you have NO memory of previous iterations.",
-      "",
-      "## Your Workflow",
-      "",
-      `1. Read the progress file at \`${progressFilePath}\` (check Patterns section first)`,
-      "2. Check workspace files and git history (`git log --oneline -10`) to understand current state",
-      "3. Pick the next incomplete task and implement it",
-      "4. Run quality checks (tests, typecheck, build \u2014 whatever the project requires)",
-      "5. Commit your changes with a clear commit message",
-      `6. Update \`${progressFilePath}\` with your progress (ALWAYS append, never replace)`,
-      "",
-      "## Progress Report Format",
-      "",
-      `APPEND to \`${progressFilePath}\`:`,
-      "```",
-      "## [Date/Time] \u2014 What was done",
-      "- What was implemented",
-      "- Files changed",
-      "- **Learnings for future iterations:**",
-      "  - Patterns discovered",
-      "  - Gotchas encountered",
-      "  - Useful context",
-      "---",
-      "```",
-      "",
-      "## Consolidate Patterns",
-      "",
-      `If you discover a reusable pattern, add it to the \`## Patterns\` section at the TOP of \`${progressFilePath}\`.`,
-      "Only add patterns that are general and reusable, not task-specific details.",
-      "",
-      "## Quality Requirements",
-      "",
-      "- Do NOT commit broken code",
-      "- Keep changes focused and minimal",
-      "- Follow existing code patterns",
-      ...state.completion_promise ? [
-        "",
-        "## Stop Condition",
-        "",
-        `To signal completion, output: <promise>${state.completion_promise}</promise>`,
-        "",
-        "ONLY output this when the task is FULLY and PERMANENTLY complete.",
-        "Do NOT output it if there is ANY remaining work.",
-        "When in doubt, do NOT output the promise \u2014 the loop will give you another turn.",
-        "",
-        "CRITICAL: Do NOT output a false promise to exit the loop.",
-        "The loop is designed to continue until genuine completion. Trust the process."
-      ] : [
-        "",
-        "## Continuous Mode",
-        "",
-        "This is a continuous/infinite loop with no completion signal.",
-        "Just do meaningful work each iteration. The loop will continue until manually cancelled.",
-        "Focus on making progress, documenting what you did, and setting up the next iteration."
-      ]
-    ].join("\n");
-  }
-  return [
-    "# Ralph Loop \u2014 Continue Mode",
-    "",
-    "You are in an automated loop. After this turn ends, the system will automatically",
-    "start a new turn with the SAME PROMPT \u2014 you do NOT need to finish everything now.",
-    "Your previous work persists in conversation history and files.",
-    "Just do meaningful work this turn and let the loop continue.",
-    "",
-    ...state.completion_promise ? [
-      "## Stop Condition",
-      "",
-      `To signal completion, output: <promise>${state.completion_promise}</promise>`,
-      "",
-      "CRITICAL \u2014 Do NOT output the promise if:",
-      '- The task says "continuously", "forever", "keep running", or "until I stop you"',
-      "- There is ANY remaining work, follow-up, or next step you could do",
-      "- You just finished one pass/cycle of a recurring task (the loop handles repetition)",
-      "- You are uncertain whether the task is truly done",
-      "",
-      "CRITICAL: Do NOT output a false promise to exit the loop, even if you think you're",
-      "stuck or should exit for other reasons. The loop is designed to continue until genuine",
-      "completion. Trust the process."
-    ] : [
-      "## Continuous Mode",
-      "",
-      "This is a continuous/infinite loop with no completion signal.",
-      "Just do meaningful work this turn and let the loop continue.",
-      "The loop will run until manually cancelled."
-    ]
-  ].join("\n");
-}
-function buildRalphPrompt(task, state) {
-  const isFresh = state.context_mode === "fresh" || !state.context_mode;
-  if (isFresh) {
-    return task;
-  }
-  const iterStr = state.max_iterations > 0 ? `${state.iteration}/${state.max_iterations}` : `${state.iteration}`;
-  const reminderLines = [
-    "<system-reminder>",
-    `Ralph Loop \u2014 Iteration ${iterStr} (Continue Mode)`,
-    "Your conversation history persists. Continue from where you left off."
-  ];
-  if (state.completion_promise) {
-    reminderLines.push(`To signal completion, output EXACTLY: <promise>${state.completion_promise}</promise>`);
-    reminderLines.push("Only output the promise when the task is FULLY and PERMANENTLY complete.");
-    reminderLines.push("Do NOT output a false promise to exit the loop.");
-  } else {
-    reminderLines.push("This is a continuous loop \u2014 no completion signal needed. Just do meaningful work.");
-  }
-  reminderLines.push("</system-reminder>");
-  const reminder = reminderLines.join("\n");
-  return task + "\n\n" + reminder;
-}
-function getRalphProgressFilePath(directory, sessionId) {
-  return join(getSessionDir(directory, sessionId), "ralph-progress.md");
-}
 function loadSessionIndex() {
   if (!existsSync$1(SESSION_INDEX_FILE)) return {};
   try {
@@ -9682,16 +9569,6 @@ function deletePersistedSession(sessionId) {
       if (existsSync$1(configFile)) unlinkSync$1(configFile);
     } catch {
     }
-    const ralphStateFile = getRalphStateFilePath(entry.directory, sessionId);
-    try {
-      if (existsSync$1(ralphStateFile)) unlinkSync$1(ralphStateFile);
-    } catch {
-    }
-    const ralphProgressFile = getRalphProgressFilePath(entry.directory, sessionId);
-    try {
-      if (existsSync$1(ralphProgressFile)) unlinkSync$1(ralphProgressFile);
-    } catch {
-    }
     const sessionDir = getSessionDir(entry.directory, sessionId);
     try {
       rmdirSync(sessionDir);
@@ -10045,7 +9922,7 @@ async function startDaemon(options) {
     const list = loadExposedTunnels().filter((t) => t.name !== name);
     saveExposedTunnels(list);
   }
-  const { ServeManager } = await import('./serveManager-C6_Vloil.mjs');
+  const { ServeManager } = await import('./serveManager-DfETVSOb.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -10157,7 +10034,7 @@ async function startDaemon(options) {
           }
         }, shouldAutoAllow2 = function(toolName, toolInput) {
           if (toolName === "AskUserQuestion") {
-            return sessionMetadata.ralphLoop?.active === true;
+            return isLoopActive(directory);
           }
           if (toolName === "Bash") {
             const inputObj = toolInput;
@@ -10170,7 +10047,7 @@ async function startDaemon(options) {
           } else if (allowedTools.has(toolName)) {
             return true;
           }
-          if (sessionMetadata.ralphLoop?.active) return true;
+          if (isLoopActive(directory)) return true;
           if (currentPermissionMode === "bypassPermissions" || currentPermissionMode === "yolo") return true;
           if ((currentPermissionMode === "acceptEdits" || currentPermissionMode === "safe-yolo") && EDIT_TOOLS.has(toolName)) return true;
           return false;
@@ -10261,10 +10138,7 @@ async function startDaemon(options) {
         const sessionCreatedAt = persisted?.createdAt || Date.now();
         let lastSpawnMeta = persisted?.spawnMeta || {};
         let sessionWasProcessing = !!options2.wasProcessing;
-        let lastAssistantText = "";
         let lastMainModel;
-        let consecutiveRalphErrors = 0;
-        const MAX_RALPH_ERRORS = 3;
         let spawnHasReceivedInit = false;
         let startupFailureRetryPending = false;
         let startupRetryMessage;
@@ -10287,23 +10161,23 @@ async function startDaemon(options) {
           stuckWatchdogTimer = setInterval(() => {
             if (!claudeProcess || claudeProcess.exitCode !== null) return;
             if (!sessionWasProcessing) return;
-            const ralphState = readRalphState(getRalphStateFilePath(directory, sessionId));
-            if (!ralphState) return;
+            if (!isLoopActive(directory)) return;
             if (claudeProcess.pid && hasActiveChildren(claudeProcess.pid)) {
               lastOutputTime = Date.now();
               return;
             }
             const elapsed = Date.now() - lastOutputTime;
             if (elapsed > STUCK_PROCESS_TIMEOUT_MS) {
-              logger.log(`[Session ${sessionId}] Ralph Loop stuck: mid-turn, no output for ${Math.round(elapsed / 1e3)}s, no child processes \u2014 killing to unblock next iteration`);
+              logger.log(`[Session ${sessionId}] Loop stuck: mid-turn, no output for ${Math.round(elapsed / 1e3)}s, no child processes \u2014 killing to resume the loop`);
               sessionService.pushMessage(
-                { type: "message", message: `Ralph Loop iteration appears stuck (no output for ${Math.round(elapsed / 6e4)} minutes, no active tools). Restarting to continue loop...`, level: "warning" },
+                { type: "message", message: `Loop appears stuck (no output for ${Math.round(elapsed / 6e4)} minutes, no active tools). Restarting to continue...`, level: "warning" },
                 "event"
               );
               claudeProcess.kill("SIGTERM");
               setTimeout(() => {
-                if (!trackedSession.stopped) {
-                  logger.log(`[Session ${sessionId}] Stuck watchdog: nudging Ralph loop to resume`);
+                if (!trackedSession.stopped && isLoopActive(directory)) {
+                  logger.log(`[Session ${sessionId}] Stuck watchdog: nudging loop to resume`);
+                  enqueueLoopContinue();
                   processMessageQueueRef?.();
                 }
               }, 3e3);
@@ -10316,6 +10190,20 @@ async function startDaemon(options) {
             stuckWatchdogTimer = null;
           }
         };
+        const enqueueLoopContinue = () => {
+          const existingQueue = sessionMetadata.messageQueue || [];
+          const text = "Continue the loop. Read LOOP.md and keep working toward the exit conditions until the Stop gate confirms completion.";
+          sessionMetadata = {
+            ...sessionMetadata,
+            messageQueue: [...existingQueue, {
+              id: randomUUID$1(),
+              text,
+              displayText: "\u{1F501} Resuming loop",
+              createdAt: Date.now()
+            }]
+          };
+          sessionService.updateMetadata(sessionMetadata);
+        };
         const signalProcessing = (processing) => {
           sessionService.sendKeepAlive(processing);
           const newState = processing ? "running" : "idle";
@@ -10395,7 +10283,7 @@ async function startDaemon(options) {
           if (options2.forceIsolation || sessionMetadata.sharing?.enabled) {
             rawPermissionMode = rawPermissionMode === "default" ? "auto-approve-all" : rawPermissionMode;
           }
-          if (sessionMetadata.ralphLoop?.active) {
+          if (isLoopActive(directory)) {
             rawPermissionMode = "bypassPermissions";
           }
           const permissionMode = toClaudePermissionMode(rawPermissionMode);
@@ -10622,10 +10510,6 @@ async function startDaemon(options) {
                         logger.log(`[Session ${sessionId}] Background task launched: ${label} (count=${backgroundTaskCount})`);
                       }
                     }
-                    const textBlocks = assistantContent.filter((b) => b.type === "text").map((b) => b.text);
-                    if (textBlocks.length > 0) {
-                      lastAssistantText += textBlocks.join("\n");
-                    }
                   }
                   if (msg.type === "result") {
                     if (msg.is_error) {
@@ -10666,8 +10550,8 @@ async function startDaemon(options) {
                     }
                   }
                   if (msg.type === "result") {
-                    const ralphActive = !!readRalphState(getRalphStateFilePath(directory, sessionId));
-                    if (!turnInitiatedByUser && !ralphActive) {
+                    const loopActive = isLoopActive(directory);
+                    if (!turnInitiatedByUser && !loopActive) {
                       logger.log(`[Session ${sessionId}] Skipping stale result from SDK-initiated turn`);
                       const hasBackgroundTasks = backgroundTaskCount > 0;
                       if (hasBackgroundTasks) {
@@ -10692,8 +10576,8 @@ async function startDaemon(options) {
                       turnInitiatedByUser = true;
                       continue;
                     }
-                    if (!turnInitiatedByUser && ralphActive) {
-                      logger.log(`[Session ${sessionId}] SDK-initiated result during active Ralph loop \u2014 processing anyway to avoid stalling`);
+                    if (!turnInitiatedByUser && loopActive) {
+                      logger.log(`[Session ${sessionId}] SDK-initiated result during active loop \u2014 processing anyway to avoid stalling`);
                       turnInitiatedByUser = true;
                     }
                     if (msg.session_id) {
@@ -10743,191 +10627,8 @@ async function startDaemon(options) {
                       sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
                     }
                     const queueLen = sessionMetadata.messageQueue?.length ?? 0;
-                    if (msg.is_error) {
-                      const rlStateForError = readRalphState(getRalphStateFilePath(directory, sessionId));
-                      if (rlStateForError) {
-                        consecutiveRalphErrors++;
-                        logger.log(`[Session ${sessionId}] Ralph loop: error result (consecutive=${consecutiveRalphErrors}/${MAX_RALPH_ERRORS})`);
-                        if (consecutiveRalphErrors >= MAX_RALPH_ERRORS) {
-                          logger.log(`[Session ${sessionId}] Ralph loop: ${MAX_RALPH_ERRORS} consecutive errors \u2014 stopping loop`);
-                          removeRalphState(getRalphStateFilePath(directory, sessionId));
-                          if (lastSpawnMeta.appendSystemPrompt) {
-                            const { appendSystemPrompt: _, ...rest } = lastSpawnMeta;
-                            lastSpawnMeta = rest;
-                          }
-                          sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
-                          sessionService.updateMetadata(sessionMetadata);
-                          sessionService.pushMessage(
-                            { type: "message", message: `Ralph loop stopped \u2014 ${consecutiveRalphErrors} consecutive errors. Last error: ${msg.result || "unknown"}`, level: "error" },
-                            "event"
-                          );
-                          consecutiveRalphErrors = 0;
-                          signalProcessing(false);
-                          sessionService.sendSessionEnd();
-                          break;
-                        }
-                      }
-                    } else {
-                      consecutiveRalphErrors = 0;
-                    }
                     if (queueLen > 0 && claudeResumeId && !trackedSession.stopped) {
                       setTimeout(() => processMessageQueueRef?.(), 200);
-                    } else if (claudeResumeId) {
-                      const rlState = readRalphState(getRalphStateFilePath(directory, sessionId));
-                      if (rlState) {
-                        let promiseFulfilled = false;
-                        if (rlState.completion_promise) {
-                          const promiseMatch = lastAssistantText.match(/<promise>([\s\S]*?)<\/promise>/);
-                          promiseFulfilled = !!(promiseMatch && promiseMatch[1].trim().replace(/\s+/g, " ") === rlState.completion_promise);
-                        }
-                        const maxReached = rlState.max_iterations > 0 && rlState.iteration >= rlState.max_iterations;
-                        if (promiseFulfilled || maxReached) {
-                          const isFreshMode = rlState.context_mode === "fresh" || !rlState.context_mode;
-                          removeRalphState(getRalphStateFilePath(directory, sessionId));
-                          if (lastSpawnMeta.appendSystemPrompt) {
-                            const { appendSystemPrompt: _, ...rest } = lastSpawnMeta;
-                            lastSpawnMeta = rest;
-                          }
-                          sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
-                          sessionService.updateMetadata(sessionMetadata);
-                          const reason = promiseFulfilled ? `Ralph loop completed at iteration ${rlState.iteration} \u2014 promise "${rlState.completion_promise}" fulfilled.` : `Ralph loop stopped \u2014 max iterations (${rlState.max_iterations}) reached.`;
-                          logger.log(`[Session ${sessionId}] ${reason}`);
-                          sessionService.pushMessage({ type: "message", message: reason }, "event");
-                          if (isFreshMode && rlState.original_resume_id) {
-                            claudeResumeId = rlState.original_resume_id;
-                            (async () => {
-                              try {
-                                if (claudeProcess && claudeProcess.exitCode === null) {
-                                  isKillingClaude = true;
-                                  await killAndWaitForExit2(claudeProcess);
-                                  isKillingClaude = false;
-                                }
-                                if (trackedSession.stopped) return;
-                                if (isRestartingClaude || isSwitchingMode) return;
-                                const progressPath = getRalphProgressFilePath(directory, sessionId);
-                                let resumeMessage;
-                                try {
-                                  if (existsSync$1(progressPath)) {
-                                    const progressContent = readFileSync$1(progressPath, "utf-8").trim();
-                                    if (progressContent) {
-                                      resumeMessage = `<system-reminder>
-The Ralph Loop has completed (${reason}).
-Below is the progress log from all iterations:
-
-${progressContent}
-</system-reminder>
-
-The automated loop has finished. Review the progress above and let me know if you need anything else.`;
-                                      unlinkSync$1(progressPath);
-                                      logger.log(`[Session ${sessionId}] Injected progress file content and deleted ${progressPath}`);
-                                    }
-                                  }
-                                } catch (progressErr) {
-                                  logger.log(`[Session ${sessionId}] Could not read/delete progress file: ${progressErr.message}`);
-                                }
-                                spawnClaude(resumeMessage);
-                                logger.log(`[Session ${sessionId}] Resumed original session ${rlState.original_resume_id}`);
-                              } catch (err) {
-                                logger.log(`[Session ${sessionId}] Error resuming original session: ${err.message}`);
-                                isKillingClaude = false;
-                              }
-                            })();
-                          } else {
-                            sessionService.sendSessionEnd();
-                          }
-                        } else {
-                          const nextIteration = rlState.iteration + 1;
-                          const iterationTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-                          const isFreshMode = rlState.context_mode === "fresh" || !rlState.context_mode;
-                          const updatedRlState = { ...rlState, iteration: nextIteration, last_iteration_at: iterationTimestamp };
-                          if (isFreshMode && !rlState.original_resume_id && claudeResumeId) {
-                            updatedRlState.original_resume_id = claudeResumeId;
-                          }
-                          try {
-                            writeRalphState(getRalphStateFilePath(directory, sessionId), updatedRlState);
-                          } catch (writeErr) {
-                            logger.log(`[Session ${sessionId}] Ralph: failed to persist state (iter ${nextIteration}): ${writeErr.message} \u2014 stopping loop`);
-                            sessionService.pushMessage({ type: "message", message: `Ralph loop error: failed to persist iteration state \u2014 loop stopped. (${writeErr.message})` }, "event");
-                            removeRalphState(getRalphStateFilePath(directory, sessionId));
-                            sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
-                            sessionService.updateMetadata(sessionMetadata);
-                            break;
-                          }
-                          const ralphLoop = {
-                            active: true,
-                            task: rlState.task,
-                            completionPromise: rlState.completion_promise ?? "none",
-                            maxIterations: rlState.max_iterations,
-                            currentIteration: nextIteration,
-                            startedAt: rlState.started_at,
-                            cooldownSeconds: rlState.cooldown_seconds,
-                            contextMode: rlState.context_mode || "fresh",
-                            lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
-                          };
-                          sessionMetadata = { ...sessionMetadata, ralphLoop };
-                          sessionService.updateMetadata(sessionMetadata);
-                          logger.log(`[Session ${sessionId}] Ralph loop iteration ${nextIteration}${rlState.max_iterations > 0 ? `/${rlState.max_iterations}` : ""}: spawning (${isFreshMode ? "fresh" : "continue"})`);
-                          const progressRelPath = `.svamp/${sessionId}/ralph-progress.md`;
-                          const prompt = buildRalphPrompt(rlState.task, updatedRlState);
-                          const ralphSysPrompt = buildRalphSystemPrompt(updatedRlState, progressRelPath);
-                          const cooldownMs = Math.max(200, rlState.cooldown_seconds * 1e3);
-                          if (isFreshMode) {
-                            isKillingClaude = true;
-                            setTimeout(async () => {
-                              try {
-                                if (claudeProcess && claudeProcess.exitCode === null) {
-                                  await killAndWaitForExit2(claudeProcess);
-                                }
-                                isKillingClaude = false;
-                                if (trackedSession.stopped) return;
-                                if (isRestartingClaude || isSwitchingMode) return;
-                                claudeResumeId = void 0;
-                                userMessagePending = true;
-                                turnInitiatedByUser = true;
-                                sessionWasProcessing = true;
-                                signalProcessing(true);
-                                sessionService.pushMessage({ type: "message", message: buildIterationStatus(nextIteration, rlState.max_iterations, rlState.completion_promise) }, "event");
-                                sessionService.pushMessage(rlState.task, "user");
-                                spawnClaude(prompt, { appendSystemPrompt: ralphSysPrompt });
-                              } catch (err) {
-                                logger.log(`[Session ${sessionId}] Error in fresh Ralph iteration: ${err.message}`);
-                                isKillingClaude = false;
-                                sessionWasProcessing = false;
-                                signalProcessing(false);
-                              }
-                            }, cooldownMs);
-                          } else {
-                            setTimeout(() => {
-                              if (trackedSession.stopped) return;
-                              if (isRestartingClaude || isSwitchingMode) return;
-                              try {
-                                userMessagePending = true;
-                                turnInitiatedByUser = true;
-                                sessionWasProcessing = true;
-                                signalProcessing(true);
-                                sessionService.pushMessage({ type: "message", message: buildIterationStatus(nextIteration, rlState.max_iterations, rlState.completion_promise) }, "event");
-                                sessionService.pushMessage(rlState.task, "user");
-                                if (claudeProcess && claudeProcess.exitCode === null) {
-                                  const stdinMsg = JSON.stringify({
-                                    type: "user",
-                                    message: { role: "user", content: prompt }
-                                  });
-                                  claudeProcess.stdin?.write(stdinMsg + "\n");
-                                } else {
-                                  spawnClaude(prompt, { appendSystemPrompt: ralphSysPrompt });
-                                }
-                              } catch (err) {
-                                logger.log(`[Session ${sessionId}] Error in continue Ralph iteration: ${err.message}`);
-                                sessionWasProcessing = false;
-                                signalProcessing(false);
-                              }
-                            }, cooldownMs);
-                          }
-                        }
-                      } else {
-                        signalProcessing(false);
-                        sessionService.sendSessionEnd();
-                      }
                     } else {
                       signalProcessing(false);
                       sessionService.sendSessionEnd();
@@ -10935,7 +10636,6 @@ The automated loop has finished. Review the progress above and let me know if yo
                   }
                   sessionService.pushMessage(msg, "agent");
                 } else if (msg.type === "system" && msg.subtype === "init") {
-                  lastAssistantText = "";
                   consecutiveOverloadRetries = 0;
                   overloadBailedThisTurn = false;
                   if (!userMessagePending) {
@@ -11241,10 +10941,6 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 signalProcessing(false);
                 return;
               }
-              if (msgMeta?.ralphFreshContext && claudeResumeId) {
-                logger.log(`[Session ${sessionId}] Ralph fresh context: clearing resumeId for fresh spawn`);
-                claudeResumeId = void 0;
-              }
               if (msgMeta?.btw && claudeResumeId) {
                 logger.log(`[Session ${sessionId}] /btw side-channel: "${text.substring(0, 80)}..."`);
                 sessionService.pushMessage(
@@ -11539,7 +11235,6 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               const newCustomTitle = newMeta.customTitle;
               const oldLink = sessionMetadata.sessionLink;
               const newLink = newMeta.sessionLink;
-              const prevRalphLoop = sessionMetadata.ralphLoop;
               sessionMetadata = {
                 ...newMeta,
                 // Daemon drives lifecycleState — don't let frontend overwrite with stale value
@@ -11549,10 +11244,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 ...sessionMetadata.summary && !newMeta.summary ? { summary: sessionMetadata.summary } : {},
                 ...sessionMetadata.sessionLink && !newMeta.sessionLink ? { sessionLink: sessionMetadata.sessionLink } : {},
                 // Preserve parentSessionId — set at spawn time, frontend may not track it
-                ...sessionMetadata.parentSessionId ? { parentSessionId: sessionMetadata.parentSessionId } : {},
-                // Preserve daemon-owned ralphLoop — frontend may send stale snapshot without it,
-                // which would wipe the active loop state and cause the bar to disappear mid-run.
-                ...prevRalphLoop ? { ralphLoop: prevRalphLoop } : {}
+                ...sessionMetadata.parentSessionId ? { parentSessionId: sessionMetadata.parentSessionId } : {}
               };
               const cfgPatch = {};
               if (newTitle !== oldTitle) cfgPatch.title = newTitle ?? null;
@@ -11567,9 +11259,6 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   logger.log(`[Session ${sessionId}] Failed to persist metadata patch: ${err.message}`);
                 }
               }
-              if (prevRalphLoop && !newMeta.ralphLoop) {
-                sessionService.updateMetadata(sessionMetadata);
-              }
               const queue = newMeta.messageQueue;
               if (queue && queue.length > 0 && !sessionWasProcessing && !trackedSession.stopped) {
                 setTimeout(() => {
@@ -11709,49 +11398,20 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             sessionService.pushMessage(next.displayText || next.text, "user");
             userMessagePending = true;
             turnInitiatedByUser = true;
-            const queueMeta = next.ralphSystemPrompt ? { appendSystemPrompt: next.ralphSystemPrompt } : void 0;
-            const rlState = readRalphState(getRalphStateFilePath(directory, sessionId));
-            const isRalphFresh = rlState && (rlState.context_mode === "fresh" || !rlState.context_mode);
-            if (isRalphFresh && claudeProcess && claudeProcess.exitCode === null) {
-              logger.log(`[Session ${sessionId}] Ralph fresh context: killing process for fresh spawn`);
-              (async () => {
-                try {
-                  if (!rlState.original_resume_id && claudeResumeId) {
-                    writeRalphState(getRalphStateFilePath(directory, sessionId), {
-                      ...rlState,
-                      original_resume_id: claudeResumeId
-                    });
-                  }
-                  isKillingClaude = true;
-                  await killAndWaitForExit2(claudeProcess);
-                  isKillingClaude = false;
-                  if (trackedSession?.stopped) return;
-                  if (isRestartingClaude || isSwitchingMode) return;
-                  claudeResumeId = void 0;
-                  spawnClaude(next.text, queueMeta);
-                } catch (err) {
-                  logger.log(`[Session ${sessionId}] Error in fresh Ralph queue processing: ${err.message}`);
-                  isKillingClaude = false;
-                  sessionWasProcessing = false;
-                  signalProcessing(false);
-                }
-              })();
-            } else {
-              try {
-                if (!claudeProcess || claudeProcess.exitCode !== null) {
-                  spawnClaude(next.text, queueMeta);
-                } else {
-                  const stdinMsg = JSON.stringify({
-                    type: "user",
-                    message: { role: "user", content: next.text }
-                  });
-                  claudeProcess.stdin?.write(stdinMsg + "\n");
-                }
-              } catch (err) {
-                logger.log(`[Session ${sessionId}] Error in processMessageQueue spawn: ${err.message}`);
-                sessionWasProcessing = false;
-                signalProcessing(false);
+            try {
+              if (!claudeProcess || claudeProcess.exitCode !== null) {
+                spawnClaude(next.text);
+              } else {
+                const stdinMsg = JSON.stringify({
+                  type: "user",
+                  message: { role: "user", content: next.text }
+                });
+                claudeProcess.stdin?.write(stdinMsg + "\n");
               }
+            } catch (err) {
+              logger.log(`[Session ${sessionId}] Error in processMessageQueue spawn: ${err.message}`);
+              sessionWasProcessing = false;
+              signalProcessing(false);
             }
           }
         };
@@ -11825,7 +11485,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           } else if (allowedTools.has(toolName)) {
             return true;
           }
-          if (sessionMetadata.ralphLoop?.active) return true;
+          if (isLoopActive(directory)) return true;
           if (currentPermissionMode === "bypassPermissions" || currentPermissionMode === "yolo") return true;
           if ((currentPermissionMode === "acceptEdits" || currentPermissionMode === "safe-yolo") && EDIT_TOOLS.has(toolName)) return true;
           return false;
@@ -12035,7 +11695,6 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               const newCustomTitleAcp = newMeta.customTitle;
               const oldLinkAcp = sessionMetadata.sessionLink;
               const newLinkAcp = newMeta.sessionLink;
-              const prevRalphLoop = sessionMetadata.ralphLoop;
               sessionMetadata = {
                 ...newMeta,
                 // Daemon drives lifecycleState — don't let frontend overwrite with stale value
@@ -12043,10 +11702,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 ...sessionMetadata.summary && !newMeta.summary ? { summary: sessionMetadata.summary } : {},
                 ...sessionMetadata.sessionLink && !newMeta.sessionLink ? { sessionLink: sessionMetadata.sessionLink } : {},
                 // Preserve parentSessionId — set at spawn time, frontend may not track it
-                ...sessionMetadata.parentSessionId ? { parentSessionId: sessionMetadata.parentSessionId } : {},
-                // Preserve daemon-owned ralphLoop — frontend may send stale snapshot without it,
-                // which would wipe the active loop state and cause the bar to disappear mid-run.
-                ...prevRalphLoop ? { ralphLoop: prevRalphLoop } : {}
+                ...sessionMetadata.parentSessionId ? { parentSessionId: sessionMetadata.parentSessionId } : {}
               };
               const cfgPatchAcp = {};
               if (newTitleAcp !== oldTitleAcp) cfgPatchAcp.title = newTitleAcp ?? null;
@@ -12061,9 +11717,6 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   logger.log(`[Session ${sessionId}] Failed to persist metadata patch: ${err.message}`);
                 }
               }
-              if (prevRalphLoop && !newMeta.ralphLoop) {
-                sessionService.updateMetadata(sessionMetadata);
-              }
               if (acpStopped) return;
               const queue = newMeta.messageQueue;
               if (queue && queue.length > 0 && sessionMetadata.lifecycleState === "idle") {
@@ -12197,7 +11850,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               const remaining = queue.slice(1);
               sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0, lifecycleState: "running" };
               sessionService.updateMetadata(sessionMetadata);
-              logger.log(`[Session ${sessionId}] Processing queued message (ACP ralph activation): "${next.text.slice(0, 50)}..."`);
+              logger.log(`[Session ${sessionId}] Processing queued message (ACP loop activation): "${next.text.slice(0, 50)}..."`);
               sessionService.sendKeepAlive(true);
               agentBackend.sendPrompt(sessionId, next.text).catch((err) => {
                 logger.error(`[Session ${sessionId}] Error processing queued message: ${err.message}`);
@@ -12279,99 +11932,6 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               }
             } catch {
             }
-            const rlState = readRalphState(getRalphStateFilePath(directory, sessionId));
-            if (rlState) {
-              let promiseFulfilled = false;
-              if (rlState.completion_promise) {
-                const promiseMatch = lastAssistantText.match(/<promise>([\s\S]*?)<\/promise>/);
-                promiseFulfilled = !!(promiseMatch && promiseMatch[1].trim().replace(/\s+/g, " ") === rlState.completion_promise);
-              }
-              const maxReached = rlState.max_iterations > 0 && rlState.iteration >= rlState.max_iterations;
-              if (promiseFulfilled || maxReached) {
-                removeRalphState(getRalphStateFilePath(directory, sessionId));
-                sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
-                sessionService.updateMetadata(sessionMetadata);
-                const reason = promiseFulfilled ? `Ralph loop completed at iteration ${rlState.iteration} \u2014 promise "${rlState.completion_promise}" fulfilled.` : `Ralph loop stopped \u2014 max iterations (${rlState.max_iterations}) reached.`;
-                logger.log(`[${agentName} Session ${sessionId}] ${reason}`);
-                sessionService.pushMessage({ type: "message", message: reason }, "event");
-              } else {
-                const pendingQueue = sessionMetadata.messageQueue;
-                if (pendingQueue && pendingQueue.length > 0) {
-                  const next = pendingQueue[0];
-                  const remaining = pendingQueue.slice(1);
-                  sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0, lifecycleState: "running" };
-                  sessionService.updateMetadata(sessionMetadata);
-                  sessionService.sendKeepAlive(true);
-                  sessionService.pushMessage(next.displayText || next.text, "user");
-                  logger.log(`[${agentName} Session ${sessionId}] Processing queued message (priority over Ralph advance): "${next.text.slice(0, 50)}..."`);
-                  agentBackend.sendPrompt(sessionId, next.text).catch((err) => {
-                    logger.error(`[${agentName} Session ${sessionId}] Error processing queued message (Ralph): ${err.message}`);
-                    if (!acpStopped) {
-                      sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
-                      sessionService.updateMetadata(sessionMetadata);
-                      sessionService.sendSessionEnd();
-                    }
-                  });
-                  return;
-                }
-                const nextIteration = rlState.iteration + 1;
-                const iterationTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-                try {
-                  writeRalphState(getRalphStateFilePath(directory, sessionId), { ...rlState, iteration: nextIteration, last_iteration_at: iterationTimestamp });
-                } catch (writeErr) {
-                  logger.log(`[${agentName} Session ${sessionId}] Ralph: failed to persist state (iter ${nextIteration}): ${writeErr.message} \u2014 stopping loop`);
-                  sessionService.pushMessage({ type: "message", message: `Ralph loop error: failed to persist iteration state \u2014 loop stopped. (${writeErr.message})` }, "event");
-                  removeRalphState(getRalphStateFilePath(directory, sessionId));
-                  sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
-                  sessionService.updateMetadata(sessionMetadata);
-                  return;
-                }
-                const ralphLoop = {
-                  active: true,
-                  task: rlState.task,
-                  completionPromise: rlState.completion_promise ?? "none",
-                  maxIterations: rlState.max_iterations,
-                  currentIteration: nextIteration,
-                  startedAt: rlState.started_at,
-                  cooldownSeconds: rlState.cooldown_seconds,
-                  contextMode: rlState.context_mode || "fresh",
-                  lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
-                };
-                sessionMetadata = { ...sessionMetadata, ralphLoop, lifecycleState: "running" };
-                sessionService.updateMetadata(sessionMetadata);
-                logger.log(`[${agentName} Session ${sessionId}] Ralph loop iteration ${nextIteration}${rlState.max_iterations > 0 ? `/${rlState.max_iterations}` : ""}: spawning`);
-                const updatedState = { ...rlState, iteration: nextIteration, context_mode: "continue" };
-                const prompt = buildRalphPrompt(rlState.task, updatedState);
-                const cooldownMs = Math.max(200, rlState.cooldown_seconds * 1e3);
-                setTimeout(() => {
-                  if (acpStopped) return;
-                  const liveRlState = readRalphState(getRalphStateFilePath(directory, sessionId));
-                  if (!liveRlState) {
-                    sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
-                    sessionService.updateMetadata(sessionMetadata);
-                    sessionService.sendKeepAlive(false);
-                    sessionService.sendSessionEnd();
-                    return;
-                  }
-                  sessionService.sendKeepAlive(true);
-                  sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
-                  sessionService.updateMetadata(sessionMetadata);
-                  sessionService.pushMessage({ type: "message", message: buildIterationStatus(nextIteration, rlState.max_iterations, rlState.completion_promise) }, "event");
-                  sessionService.pushMessage(rlState.task, "user");
-                  agentBackend.sendPrompt(sessionId, prompt).catch((err) => {
-                    logger.error(`[${agentName} Session ${sessionId}] Error in Ralph loop: ${err.message}`);
-                    if (!acpStopped) {
-                      removeRalphState(getRalphStateFilePath(directory, sessionId));
-                      sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
-                      sessionService.updateMetadata(sessionMetadata);
-                      sessionService.sendSessionEnd();
-                      sessionService.pushMessage({ type: "message", message: `Ralph loop error: agent failed to start turn \u2014 loop stopped. (${err.message})` }, "event");
-                    }
-                  });
-                }, cooldownMs);
-                return;
-              }
-            }
             const queue = sessionMetadata.messageQueue;
             if (queue && queue.length > 0) {
               const next = queue[0];
@@ -12673,7 +12233,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-BZ4l4-os.mjs');
+      const { FrpcTunnel } = await import('./frpc-WVnBbyjf.mjs');
       for (const spec of specs) {
         if (tunnels.has(spec.name)) continue;
         try {
@@ -12754,7 +12314,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
       logger.log(`[staged-homes] sweep failed: ${err.message}`);
     }
     const sessionsToAutoContinue = [];
-    const sessionsToRalphResume = [];
+    const sessionsToLoopResume = [];
     if (persistedSessions.length > 0) {
       logger.log(`Restoring ${persistedSessions.length} persisted session(s)...`);
       for (const persisted of persistedSessions) {
@@ -12799,11 +12359,8 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             if (persisted.wasProcessing && persisted.claudeResumeId && !isOrphaned) {
               sessionsToAutoContinue.push(persisted.sessionId);
             }
-            if (!isOrphaned && !persisted.wasProcessing) {
-              const rlState = readRalphState(getRalphStateFilePath(persisted.directory, persisted.sessionId));
-              if (rlState) {
-                sessionsToRalphResume.push({ sessionId: persisted.sessionId, directory: persisted.directory });
-              }
+            if (!isOrphaned && !persisted.wasProcessing && isLoopActive(persisted.directory)) {
+              sessionsToLoopResume.push({ sessionId: persisted.sessionId, directory: persisted.directory });
             }
           } else {
             logger.log(`Failed to restore session ${persisted.sessionId}: ${result.type}`);
@@ -12837,54 +12394,34 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
     } else if (sessionsToAutoContinue.length > 0) {
       logger.log(`Skipping auto-continue for ${sessionsToAutoContinue.length} interrupted session(s) (--no-auto-continue)`);
     }
-    if (sessionsToRalphResume.length > 0 && !options?.noAutoContinue) {
-      logger.log(`Resuming Ralph loop for ${sessionsToRalphResume.length} session(s)...`);
-      for (const { sessionId, directory: sessDir } of sessionsToRalphResume) {
+    if (sessionsToLoopResume.length > 0 && !options?.noAutoContinue) {
+      logger.log(`Resuming loop for ${sessionsToLoopResume.length} session(s)...`);
+      for (const { sessionId, directory: sessDir } of sessionsToLoopResume) {
         try {
           const tracked = Array.from(pidToTrackedSession.values()).find((s) => s.svampSessionId === sessionId);
           const rpc = tracked?.sessionRPCHandlers;
           if (!rpc) {
-            logger.log(`Session ${sessionId} RPC handlers not found for Ralph resume`);
+            logger.log(`Session ${sessionId} RPC handlers not found for loop resume`);
             continue;
           }
-          const rlState = readRalphState(getRalphStateFilePath(sessDir, sessionId));
-          if (!rlState) continue;
-          const initDelayMs = 2e3;
-          let resumeDelayMs = initDelayMs;
-          if (rlState.last_iteration_at) {
-            const lastIterTime = new Date(rlState.last_iteration_at).getTime();
-            const cooldownMs = Math.max(200, rlState.cooldown_seconds * 1e3);
-            const elapsedMs = Date.now() - lastIterTime;
-            const remainingCooldownMs = cooldownMs - elapsedMs;
-            resumeDelayMs = Math.max(initDelayMs, remainingCooldownMs + initDelayMs);
-            logger.log(`Ralph loop for session ${sessionId}: cooldown ${rlState.cooldown_seconds}s, elapsed ${Math.round(elapsedMs / 1e3)}s, resuming in ${Math.round(resumeDelayMs / 1e3)}s`);
-          }
           setTimeout(async () => {
             try {
-              const currentState = readRalphState(getRalphStateFilePath(sessDir, sessionId));
-              if (!currentState) return;
-              const isFreshMode = currentState.context_mode === "fresh" || !currentState.context_mode;
-              const progressRelPath = `.svamp/${sessionId}/ralph-progress.md`;
-              const prompt = buildRalphPrompt(currentState.task, currentState);
-              const ralphSysPrompt = buildRalphSystemPrompt(currentState, progressRelPath);
+              if (!isLoopActive(sessDir)) return;
+              const prompt = "Continue the loop. Read LOOP.md and keep working toward the exit conditions until the Stop gate confirms completion.";
               await rpc.sendMessage(
                 JSON.stringify({
                   role: "user",
                   content: { type: "text", text: prompt },
-                  meta: {
-                    sentFrom: "svamp-daemon-ralph-resume",
-                    appendSystemPrompt: ralphSysPrompt,
-                    ...isFreshMode ? { ralphFreshContext: true } : {}
-                  }
+                  meta: { sentFrom: "svamp-daemon-loop-resume" }
                 })
               );
-              logger.log(`Resumed Ralph loop for session ${sessionId} at iteration ${currentState.iteration} (${isFreshMode ? "fresh" : "continue"})`);
+              logger.log(`Resumed loop for session ${sessionId}`);
             } catch (err) {
-              logger.log(`Failed to resume Ralph loop for session ${sessionId}: ${err.message}`);
+              logger.log(`Failed to resume loop for session ${sessionId}: ${err.message}`);
             }
-          }, resumeDelayMs);
+          }, 2e3);
         } catch (err) {
-          logger.log(`Failed to find session service for Ralph resume ${sessionId}: ${err.message}`);
+          logger.log(`Failed to find session service for loop resume ${sessionId}: ${err.message}`);
         }
       }
     }