svamp-cli 0.1.51 → 0.1.53

package/dist/{run-C0ecvcRP.mjs → run-BnnUavlu.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");
@@ -3772,7 +3780,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 +3794,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,11 +3876,13 @@ 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`;
@@ -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,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();
@@ -3999,7 +4015,7 @@ 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 buildRalphSystemPrompt(state, progressFilePath) {
   const isFresh = state.context_mode === "fresh" || !state.context_mode;
@@ -4043,17 +4059,26 @@ function buildRalphSystemPrompt(state, progressFilePath) {
       "- Do NOT commit broken code",
       "- Keep changes focused and minimal",
       "- Follow existing code patterns",
-      "",
-      "## 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."
+      ...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 [
@@ -4064,19 +4089,27 @@ function buildRalphSystemPrompt(state, progressFilePath) {
     "Your previous work persists in conversation history and files.",
     "Just do meaningful work this turn and let the loop continue.",
     "",
-    "## 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."
+    ...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) {
@@ -4085,9 +4118,24 @@ 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 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 {};
@@ -4828,8 +4876,11 @@ 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;
@@ -4852,7 +4903,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}`);
@@ -4874,11 +4946,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);
@@ -5215,6 +5289,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);
@@ -5546,6 +5625,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);
@@ -5737,8 +5819,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));
@@ -5754,11 +5839,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);

package/dist/{run-3Et1ISd5.mjs → run-Bw6aGHLA.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-BdEHYoYE.mjs';
+import { c as connectToHypha, a as registerSessionService } from './run-BnnUavlu.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';