svamp-cli 0.1.51 → 0.1.53

package/dist/{run-CE4H8ZiN.mjs → run-CBhm4Jop.mjs}

@@ -1058,6 +1058,14 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         });
         return await callbacks.onUpdateSecurityContext(newSecurityContext);
       },
+      /** Apply a new system prompt and restart the agent process */
+      applySystemPrompt: async (prompt, context) => {
+        authorizeRequest(context, metadata.sharing, "admin");
+        if (!callbacks.onApplySystemPrompt) {
+          throw new Error("System prompt updates are not supported for this session");
+        }
+        return await callbacks.onApplySystemPrompt(prompt);
+      },
       // ── Listener Registration ──
       registerListener: async (callback, context) => {
         authorizeRequest(context, metadata.sharing, "view");
@@ -3678,23 +3686,28 @@ function sanitizeEnvForSharing(env) {
 
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname(__filename$1);
-function loadDotEnv() {
-  const envDir = process.env.SVAMP_HOME || join(os__default.homedir(), ".svamp");
-  const envFile = join(envDir, ".env");
-  if (existsSync$1(envFile)) {
-    const lines = readFileSync$1(envFile, "utf-8").split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eqIdx = trimmed.indexOf("=");
-      if (eqIdx === -1) continue;
-      const key = trimmed.slice(0, eqIdx).trim();
-      const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
-      if (!process.env[key]) {
-        process.env[key] = value;
-      }
+function loadEnvFile(path) {
+  if (!existsSync$1(path)) return false;
+  const lines = readFileSync$1(path, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+    if (!process.env[key]) {
+      process.env[key] = value;
     }
   }
+  return true;
+}
+function loadDotEnv() {
+  const svampEnv = join(process.env.SVAMP_HOME || os__default.homedir() + "/.svamp", ".env");
+  if (!loadEnvFile(svampEnv)) {
+    const hyphaEnv = join(process.env.HYPHA_HOME || os__default.homedir() + "/.hypha", ".env");
+    loadEnvFile(hyphaEnv);
+  }
 }
 loadDotEnv();
 const SVAMP_HOME = process.env.SVAMP_HOME || join(os__default.homedir(), ".svamp");
@@ -3772,7 +3785,7 @@ function readRalphState(filePath) {
     return {
       iteration: parseInt(fields.iteration || "1", 10) || 1,
       max_iterations: parseInt(fields.max_iterations || "0", 10) || 0,
-      completion_promise: fields.completion_promise || "DONE",
+      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,
@@ -3786,7 +3799,7 @@ function readRalphState(filePath) {
 }
 function writeRalphState(filePath, state) {
   mkdirSync(dirname(filePath), { recursive: true });
-  const promiseYaml = state.completion_promise.includes(":") || state.completion_promise.includes('"') ? `"${state.completion_promise.replace(/"/g, '\\"')}"` : `"${state.completion_promise}"`;
+  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 ? `
@@ -3868,20 +3881,29 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
       const ralphLoop = {
         active: true,
         task: state.task,
-        completionPromise: state.completion_promise,
+        completionPromise: state.completion_promise ?? "none",
         maxIterations: state.max_iterations,
         currentIteration: state.iteration,
         startedAt: state.started_at,
-        cooldownSeconds: state.cooldown_seconds
+        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, progressRelPath);
+        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() }]
+          messageQueue: [...existingQueue, {
+            id: randomUUID$1(),
+            text: prompt,
+            displayText: state.task,
+            createdAt: Date.now(),
+            ralphSystemPrompt: ralphSysPrompt
+          }]
         }));
         sessionService.updateMetadata(getMetadata());
         sessionService.pushMessage(
@@ -3890,7 +3912,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         );
         logger.log(`[svampConfig] Ralph loop started: "${state.task.slice(0, 50)}..."`);
         onRalphLoopActivated?.();
-      } else if (prevRalph.currentIteration !== ralphLoop.currentIteration) {
+      } else if (prevRalph.currentIteration !== ralphLoop.currentIteration || prevRalph.task !== ralphLoop.task) {
         setMetadata((m) => ({ ...m, ralphLoop }));
         sessionService.updateMetadata(getMetadata());
       }
@@ -3940,12 +3962,18 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
     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: rl.current_iteration || 1,
           max_iterations: typeof rl.max_iterations === "number" ? rl.max_iterations : 0,
-          completion_promise: rl.completion_promise || "DONE",
-          cooldown_seconds: typeof rl.cooldown_seconds === "number" ? rl.cooldown_seconds : 1,
+          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()
         });
         ralphChecker();
@@ -3992,64 +4020,128 @@ function buildIterationStatus(iteration, maxIterations, completionPromise) {
   if (completionPromise) {
     return `Ralph iteration ${iterStr} | To stop: output <promise>${completionPromise}</promise>`;
   }
-  return `Ralph iteration ${iterStr} | No completion promise set - loop runs until max iterations or manual cancel`;
+  return `Ralph iteration ${iterStr} | Manual stop only`;
 }
-function buildRalphPrompt(task, state, progressFilePath) {
-  const iterStr = state.max_iterations > 0 ? `${state.iteration}/${state.max_iterations}` : `${state.iteration}`;
+function buildRalphSystemPrompt(state, progressFilePath) {
   const isFresh = state.context_mode === "fresh" || !state.context_mode;
   if (isFresh && progressFilePath) {
     return [
-      task,
+      "# 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)`,
       "",
-      `--- Ralph Loop (iteration ${iterStr}) ---`,
+      "## Progress Report Format",
       "",
-      "This is iteration " + iterStr + " of an automated loop. Each iteration runs with",
-      "FRESH CONTEXT \u2014 you have NO memory of previous iterations. Your only link to past work is:",
+      `APPEND to \`${progressFilePath}\`:`,
+      "```",
+      "## [Date/Time] \u2014 What was done",
+      "- What was implemented",
+      "- Files changed",
+      "- **Learnings for future iterations:**",
+      "  - Patterns discovered",
+      "  - Gotchas encountered",
+      "  - Useful context",
+      "---",
+      "```",
       "",
-      `1. **Progress file**: Read \`${progressFilePath}\` for what was accomplished,`,
-      "   decisions made, and what to do next.",
-      "2. **Workspace files**: Your previous iterations' code changes persist on disk and in git.",
-      "3. **Git history**: Run `git log --oneline -10` to see recent commits.",
+      "## Consolidate Patterns",
       "",
-      "WORKFLOW:",
-      "1. Read the progress file FIRST to understand current state",
-      "2. Work on the NEXT incomplete task (one task per iteration)",
-      "3. Verify your work (run tests, build, etc.)",
-      `4. BEFORE FINISHING: Update \`${progressFilePath}\` with:`,
-      "   - What you accomplished this iteration",
-      "   - Key decisions made and why",
-      "   - Files changed",
-      "   - What should be done next",
-      '   - Any reusable patterns discovered (add to top "Patterns" section)',
+      `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.",
       "",
-      "COMPLETION:",
-      `Output <promise>${state.completion_promise}</promise> ONLY 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."
+      "## 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 [
-    task,
-    "",
-    `--- Ralph Loop (iteration ${iterStr}) ---`,
+    "# 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 task \u2014 you do NOT need to finish everything now.",
-    "Your previous work persists in conversation history. Just do meaningful work this",
-    "turn and let the loop continue.",
-    "",
-    "COMPLETION:",
-    `Output <promise>${state.completion_promise}</promise> ONLY when the task is FULLY and PERMANENTLY complete.`,
+    "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.",
     "",
-    "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",
-    "",
-    "When in doubt: do NOT output the promise. The loop will give you another turn."
+    ...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 {
@@ -4789,12 +4881,19 @@ async function startDaemon(options) {
                     } else if (claudeResumeId) {
                       const rlState = readRalphState(getRalphStateFilePath(directory, sessionId));
                       if (rlState) {
-                        const promiseMatch = lastAssistantText.match(/<promise>([\s\S]*?)<\/promise>/);
-                        const promiseFulfilled = promiseMatch && promiseMatch[1].trim().replace(/\s+/g, " ") === rlState.completion_promise;
+                        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.`;
@@ -4809,7 +4908,28 @@ async function startDaemon(options) {
                                   isKillingClaude = false;
                                 }
                                 claudeResumeId = rlState.original_resume_id;
-                                spawnClaude(void 0);
+                                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(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}`);
@@ -4831,17 +4951,20 @@ async function startDaemon(options) {
                           const ralphLoop = {
                             active: true,
                             task: rlState.task,
-                            completionPromise: rlState.completion_promise,
+                            completionPromise: rlState.completion_promise ?? "none",
                             maxIterations: rlState.max_iterations,
                             currentIteration: nextIteration,
                             startedAt: rlState.started_at,
-                            cooldownSeconds: rlState.cooldown_seconds
+                            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, progressRelPath);
+                          const prompt = buildRalphPrompt(rlState.task, updatedRlState);
+                          const ralphSysPrompt = buildRalphSystemPrompt(updatedRlState, progressRelPath);
                           const cooldownMs = Math.max(200, rlState.cooldown_seconds * 1e3);
                           if (isFreshMode) {
                             setTimeout(async () => {
@@ -4858,7 +4981,7 @@ async function startDaemon(options) {
                                 signalProcessing(true);
                                 sessionService.pushMessage({ type: "message", message: buildIterationStatus(nextIteration, rlState.max_iterations, rlState.completion_promise) }, "event");
                                 sessionService.pushMessage(rlState.task, "user");
-                                spawnClaude(prompt);
+                                spawnClaude(prompt, { appendSystemPrompt: ralphSysPrompt });
                               } catch (err) {
                                 logger.log(`[Session ${sessionId}] Error in fresh Ralph iteration: ${err.message}`);
                                 isKillingClaude = false;
@@ -4880,7 +5003,7 @@ async function startDaemon(options) {
                                 });
                                 claudeProcess.stdin?.write(stdinMsg + "\n");
                               } else {
-                                spawnClaude(prompt);
+                                spawnClaude(prompt, { appendSystemPrompt: ralphSysPrompt });
                               }
                             }, cooldownMs);
                           }
@@ -5171,6 +5294,11 @@ async function startDaemon(options) {
               sessionMetadata = { ...sessionMetadata, securityContext: newSecurityContext };
               return await restartClaudeHandler();
             },
+            onApplySystemPrompt: async (prompt) => {
+              logger.log(`[Session ${sessionId}] System prompt update requested \u2014 restarting agent`);
+              lastSpawnMeta = { ...lastSpawnMeta, appendSystemPrompt: prompt };
+              return await restartClaudeHandler();
+            },
             onKillSession: () => {
               logger.log(`[Session ${sessionId}] Kill session requested`);
               stopSession(sessionId);
@@ -5309,6 +5437,7 @@ async function startDaemon(options) {
             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) {
@@ -5325,7 +5454,7 @@ async function startDaemon(options) {
                   await killAndWaitForExit2(claudeProcess);
                   isKillingClaude = false;
                   claudeResumeId = void 0;
-                  spawnClaude(next.text);
+                  spawnClaude(next.text, queueMeta);
                 } catch (err) {
                   logger.log(`[Session ${sessionId}] Error in fresh Ralph queue processing: ${err.message}`);
                   isKillingClaude = false;
@@ -5333,7 +5462,7 @@ async function startDaemon(options) {
                 }
               })();
             } else if (!claudeProcess || claudeProcess.exitCode !== null) {
-              spawnClaude(next.text);
+              spawnClaude(next.text, queueMeta);
             } else {
               const stdinMsg = JSON.stringify({
                 type: "user",
@@ -5501,6 +5630,9 @@ async function startDaemon(options) {
               sessionMetadata = { ...sessionMetadata, securityContext: newSecurityContext };
               return { success: false, message: "Security context updates with restart are not yet supported for this agent type." };
             },
+            onApplySystemPrompt: async () => {
+              return { success: false, message: "System prompt updates with restart are not yet supported for this agent type." };
+            },
             onKillSession: () => {
               logger.log(`[${agentName} Session ${sessionId}] Kill session requested`);
               stopSession(sessionId);
@@ -5692,8 +5824,11 @@ async function startDaemon(options) {
           checkSvampConfig?.();
           const rlState = readRalphState(getRalphStateFilePath(directory, sessionId));
           if (rlState) {
-            const promiseMatch = lastAssistantText.match(/<promise>([\s\S]*?)<\/promise>/);
-            const promiseFulfilled = promiseMatch && promiseMatch[1].trim().replace(/\s+/g, " ") === rlState.completion_promise;
+            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));
@@ -5709,11 +5844,13 @@ async function startDaemon(options) {
               const ralphLoop = {
                 active: true,
                 task: rlState.task,
-                completionPromise: rlState.completion_promise,
+                completionPromise: rlState.completion_promise ?? "none",
                 maxIterations: rlState.max_iterations,
                 currentIteration: nextIteration,
                 startedAt: rlState.started_at,
-                cooldownSeconds: rlState.cooldown_seconds
+                cooldownSeconds: rlState.cooldown_seconds,
+                contextMode: rlState.context_mode || "fresh",
+                lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
               };
               sessionMetadata = { ...sessionMetadata, ralphLoop };
               sessionService.updateMetadata(sessionMetadata);
@@ -5993,13 +6130,15 @@ async function startDaemon(options) {
               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, progressRelPath);
+              const prompt = buildRalphPrompt(currentState.task, currentState);
+              const ralphSysPrompt = buildRalphSystemPrompt(currentState, progressRelPath);
               await svc.sendMessage(
                 JSON.stringify({
                   role: "user",
                   content: { type: "text", text: prompt },
                   meta: {
                     sentFrom: "svamp-daemon-ralph-resume",
+                    appendSystemPrompt: ralphSysPrompt,
                     ...isFreshMode ? { ralphFreshContext: true } : {}
                   }
                 })

package/dist/{run-BE_AIJ7z.mjs → run-DOwarObi.mjs}

@@ -2,7 +2,7 @@ import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(im
 import os from 'node:os';
 import { join, resolve } from 'node:path';
 import { mkdirSync, writeFileSync, existsSync, unlinkSync, readFileSync, watch } from 'node:fs';
-import { c as connectToHypha, a as registerSessionService } from './run-Bl8OkKyC.mjs';
+import { c as connectToHypha, a as registerSessionService } from './run-DxISzP_V.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';

package/dist/{run-Bc83CRUn.mjs → run-DxISzP_V.mjs}

@@ -1058,6 +1058,14 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         });
         return await callbacks.onUpdateSecurityContext(newSecurityContext);
       },
+      /** Apply a new system prompt and restart the agent process */
+      applySystemPrompt: async (prompt, context) => {
+        authorizeRequest(context, metadata.sharing, "admin");
+        if (!callbacks.onApplySystemPrompt) {
+          throw new Error("System prompt updates are not supported for this session");
+        }
+        return await callbacks.onApplySystemPrompt(prompt);
+      },
       // ── Listener Registration ──
       registerListener: async (callback, context) => {
         authorizeRequest(context, metadata.sharing, "view");
@@ -3872,7 +3880,9 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         maxIterations: state.max_iterations,
         currentIteration: state.iteration,
         startedAt: state.started_at,
-        cooldownSeconds: state.cooldown_seconds
+        cooldownSeconds: state.cooldown_seconds,
+        contextMode: state.context_mode || "fresh",
+        lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       if (!prevRalph?.active) {
         const progressRelPath = `.svamp/${sessionId}/ralph-progress.md`;
@@ -3897,7 +3907,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         );
         logger.log(`[svampConfig] Ralph loop started: "${state.task.slice(0, 50)}..."`);
         onRalphLoopActivated?.();
-      } else if (prevRalph.currentIteration !== ralphLoop.currentIteration) {
+      } else if (prevRalph.currentIteration !== ralphLoop.currentIteration || prevRalph.task !== ralphLoop.task) {
         setMetadata((m) => ({ ...m, ralphLoop }));
         sessionService.updateMetadata(getMetadata());
       }
@@ -3947,12 +3957,14 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
     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: rl.current_iteration || 1,
           max_iterations: typeof rl.max_iterations === "number" ? rl.max_iterations : 0,
           completion_promise: rl.completion_promise || "DONE",
           cooldown_seconds: typeof rl.cooldown_seconds === "number" ? rl.cooldown_seconds : 1,
           started_at: rl.started_at || (/* @__PURE__ */ new Date()).toISOString(),
+          context_mode: contextMode,
           task: rl.task.trim()
         });
         ralphChecker();
@@ -4085,9 +4097,16 @@ function buildRalphPrompt(task, state) {
     return task;
   }
   const iterStr = state.max_iterations > 0 ? `${state.iteration}/${state.max_iterations}` : `${state.iteration}`;
-  return task + `
-
-[Ralph iteration ${iterStr} \u2014 to complete: output <promise>${state.completion_promise}</promise> ONLY when truly done]`;
+  const reminder = [
+    "<system-reminder>",
+    `Ralph Loop \u2014 Iteration ${iterStr} (Continue Mode)`,
+    "Your conversation history persists. Continue from where you left off.",
+    `To signal completion, output EXACTLY: <promise>${state.completion_promise}</promise>`,
+    "Only output the promise when the task is FULLY and PERMANENTLY complete.",
+    "Do NOT output a false promise to exit the loop.",
+    "</system-reminder>"
+  ].join("\n");
+  return task + "\n\n" + reminder;
 }
 function getRalphProgressFilePath(directory, sessionId) {
   return join(getSessionDir(directory, sessionId), "ralph-progress.md");
@@ -4902,7 +4921,9 @@ The automated loop has finished. Review the progress above and let me know if yo
                             maxIterations: rlState.max_iterations,
                             currentIteration: nextIteration,
                             startedAt: rlState.started_at,
-                            cooldownSeconds: rlState.cooldown_seconds
+                            cooldownSeconds: rlState.cooldown_seconds,
+                            contextMode: rlState.context_mode || "fresh",
+                            lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
                           };
                           sessionMetadata = { ...sessionMetadata, ralphLoop };
                           sessionService.updateMetadata(sessionMetadata);
@@ -5239,6 +5260,11 @@ The automated loop has finished. Review the progress above and let me know if yo
               sessionMetadata = { ...sessionMetadata, securityContext: newSecurityContext };
               return await restartClaudeHandler();
             },
+            onApplySystemPrompt: async (prompt) => {
+              logger.log(`[Session ${sessionId}] System prompt update requested \u2014 restarting agent`);
+              lastSpawnMeta = { ...lastSpawnMeta, appendSystemPrompt: prompt };
+              return await restartClaudeHandler();
+            },
             onKillSession: () => {
               logger.log(`[Session ${sessionId}] Kill session requested`);
               stopSession(sessionId);
@@ -5570,6 +5596,9 @@ The automated loop has finished. Review the progress above and let me know if yo
               sessionMetadata = { ...sessionMetadata, securityContext: newSecurityContext };
               return { success: false, message: "Security context updates with restart are not yet supported for this agent type." };
             },
+            onApplySystemPrompt: async () => {
+              return { success: false, message: "System prompt updates with restart are not yet supported for this agent type." };
+            },
             onKillSession: () => {
               logger.log(`[${agentName} Session ${sessionId}] Kill session requested`);
               stopSession(sessionId);
@@ -5782,7 +5811,9 @@ The automated loop has finished. Review the progress above and let me know if yo
                 maxIterations: rlState.max_iterations,
                 currentIteration: nextIteration,
                 startedAt: rlState.started_at,
-                cooldownSeconds: rlState.cooldown_seconds
+                cooldownSeconds: rlState.cooldown_seconds,
+                contextMode: rlState.context_mode || "fresh",
+                lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
               };
               sessionMetadata = { ...sessionMetadata, ralphLoop };
               sessionService.updateMetadata(sessionMetadata);

package/dist/{run-4li60ojK.mjs → run-Y0b60UYS.mjs}

@@ -2,7 +2,7 @@ import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(im
 import os from 'node:os';
 import { join, resolve } from 'node:path';
 import { mkdirSync, writeFileSync, existsSync, unlinkSync, readFileSync, watch } from 'node:fs';
-import { c as connectToHypha, a as registerSessionService } from './run-DA-YBjNw.mjs';
+import { c as connectToHypha, a as registerSessionService } from './run-CBhm4Jop.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';