opencode-ralph-rlm 0.1.8 → 0.1.9

package/README.md

@@ -221,7 +221,8 @@ Create `.opencode/ralph.json`. All fields are optional — the plugin runs with
 | `statusVerbosity` | `"normal"` | Supervisor status emission level: `minimal` (warnings/errors), `normal`, or `verbose`. |
 | `maxAttempts` | `20` | Hard stop after this many failed verify attempts. |
 | `heartbeatMinutes` | `15` | Warn if active strategist/worker has no progress for this many minutes. |
-| `verify.command` | — | Shell command to run as an array, e.g. `["bun", "run", "verify"]`. If omitted, verify always returns `unknown`. |
+| `verifyTimeoutMinutes` | `0` | Timeout for verify command in minutes. `0` disables timeouts. |
+| `verify.command` | - | Shell command to run as an array, e.g. `["bun", "run", "verify"]`. If omitted, verify always returns `unknown`. |
 | `verify.cwd` | `"."` | Working directory for the verify command, relative to the repo root. |
 | `gateDestructiveToolsUntilContextLoaded` | `true` | Block `write`, `edit`, `bash`, etc. until `ralph_load_context()` has been called in the current attempt. |
 | `maxRlmSliceLines` | `200` | Maximum lines a single `rlm_slice` call may return. |
@@ -439,6 +440,8 @@ Stop supervision for the current process. This prevents further auto-loop orches
 
 - Use this when you want to pause/stop Ralph from spawning more sessions.
 - Use this after verification passes and the user confirms they are done, or when the user asks to stop the loop.
+- Active child sessions are aborted and any running verify command is stopped.
+- Pass `delete_sessions: true` to delete child sessions after aborting them.
 - Resume later with `ralph_create_supervisor_session(restart_if_done=true)`.
 
 #### `ralph_supervision_status()`

package/dist/ralph-rlm.js

@@ -23417,6 +23417,7 @@ var RalphConfigSchema = exports_Schema.Struct({
   statusVerbosity: exports_Schema.optional(exports_Schema.Union(exports_Schema.Literal("minimal"), exports_Schema.Literal("normal"), exports_Schema.Literal("verbose"))),
   maxAttempts: exports_Schema.optional(exports_Schema.Number),
   heartbeatMinutes: exports_Schema.optional(exports_Schema.Number),
+  verifyTimeoutMinutes: exports_Schema.optional(exports_Schema.Number),
   verify: exports_Schema.optional(VerifyConfigSchema),
   gateDestructiveToolsUntilContextLoaded: exports_Schema.optional(exports_Schema.Boolean),
   maxRlmSliceLines: exports_Schema.optional(exports_Schema.Number),
@@ -23455,6 +23456,7 @@ var CONFIG_DEFAULTS = {
   statusVerbosity: "normal",
   maxAttempts: 20,
   heartbeatMinutes: 15,
+  verifyTimeoutMinutes: 0,
   gateDestructiveToolsUntilContextLoaded: true,
   maxRlmSliceLines: 200,
   requireGrepBeforeLargeSlice: true,
@@ -23480,6 +23482,7 @@ function resolveConfig(raw) {
     statusVerbosity: raw.statusVerbosity ?? CONFIG_DEFAULTS.statusVerbosity,
     maxAttempts: toBoundedInt(raw.maxAttempts, CONFIG_DEFAULTS.maxAttempts, 1, 500),
     heartbeatMinutes: toBoundedInt(raw.heartbeatMinutes, CONFIG_DEFAULTS.heartbeatMinutes, 1, 240),
+    verifyTimeoutMinutes: toBoundedInt(raw.verifyTimeoutMinutes, CONFIG_DEFAULTS.verifyTimeoutMinutes, 0, 240),
     ...verify !== undefined ? { verify } : {},
     gateDestructiveToolsUntilContextLoaded: raw.gateDestructiveToolsUntilContextLoaded ?? CONFIG_DEFAULTS.gateDestructiveToolsUntilContextLoaded,
     maxRlmSliceLines,
@@ -23762,7 +23765,26 @@ var writePendingInput = async (root, data) => {
   await NodeFs.writeFile(p, JSON.stringify(data, null, 2), "utf8");
 };
 var sleep5 = (ms) => new Promise((r) => setTimeout(r, ms));
-async function runCommand(command, cwd) {
+var activeCommands = new Set;
+var stopCommand = (cmd, reason) => {
+  if (cmd.child.killed)
+    return;
+  cmd.timedOut = cmd.timedOut || reason === "timeout";
+  try {
+    cmd.child.kill();
+  } catch {}
+  cmd.killTimer = setTimeout(() => {
+    try {
+      cmd.child.kill("SIGKILL");
+    } catch {}
+  }, 2000);
+};
+var stopAllCommands = (reason) => {
+  for (const cmd of activeCommands) {
+    stopCommand(cmd, reason);
+  }
+};
+async function runCommand(command, cwd, options) {
   return await new Promise((resolve) => {
     const child = spawn(command[0] ?? "", command.slice(1), {
       cwd,
@@ -23772,6 +23794,18 @@ async function runCommand(command, cwd) {
     });
     let stdout = "";
     let stderr = "";
+    const entry = {
+      child,
+      label: options?.label ?? command.join(" "),
+      startedAt: Date.now(),
+      timedOut: false
+    };
+    activeCommands.add(entry);
+    if (options?.timeoutMs && options.timeoutMs > 0) {
+      entry.timeoutTimer = setTimeout(() => {
+        stopCommand(entry, "timeout");
+      }, options.timeoutMs);
+    }
     child.stdout?.on("data", (chunk3) => {
       stdout += String(chunk3);
     });
@@ -23779,11 +23813,23 @@ async function runCommand(command, cwd) {
       stderr += String(chunk3);
     });
     child.on("error", (err) => {
+      if (entry.timeoutTimer)
+        clearTimeout(entry.timeoutTimer);
+      if (entry.killTimer)
+        clearTimeout(entry.killTimer);
+      activeCommands.delete(entry);
       resolve({ ok: false, code: null, stdout, stderr: `${stderr}
 ${String(err)}`.trim() });
     });
     child.on("close", (code) => {
-      resolve({ ok: code === 0, code, stdout, stderr });
+      if (entry.timeoutTimer)
+        clearTimeout(entry.timeoutTimer);
+      if (entry.killTimer)
+        clearTimeout(entry.killTimer);
+      activeCommands.delete(entry);
+      const timeoutNote = entry.timedOut ? `
+[ralph] command timed out` : "";
+      resolve({ ok: code === 0 && !entry.timedOut, code, stdout, stderr: `${stderr}${timeoutNote}`.trim() });
     });
   });
 }
@@ -24295,9 +24341,11 @@ var RalphRLM = async ({ client, $, worktree }) => {
     }
     const verifyCmd = cfg.verify.command;
     const cwd = NodePath.join(root, cfg.verify.cwd ?? ".");
+    const timeoutMs = cfg.verifyTimeoutMinutes > 0 ? cfg.verifyTimeoutMinutes * 60000 : null;
     return yield* exports_Effect.tryPromise({
       try: async () => {
-        const result = await runCommand(verifyCmd, cwd);
+        const options = timeoutMs ? { timeoutMs, label: "verify" } : { label: "verify" };
+        const result = await runCommand(verifyCmd, cwd, options);
         if (result.ok) {
           return JSON.stringify({ verdict: "pass", output: result.stdout }, null, 2);
         }
@@ -25024,6 +25072,7 @@ No pending questions found.`));
     description: "Stop Ralph supervision for this process. Prevents further auto-loop orchestration until restarted.",
     args: {
       reason: tool.schema.string().optional().describe("Optional reason for ending supervision."),
+      delete_sessions: tool.schema.boolean().optional().describe("Also delete child sessions after aborting them (default false)."),
       clear_binding: tool.schema.boolean().optional().describe("Clear supervisor session binding after stop (default false).")
     },
     async execute(args2, ctx) {
@@ -25031,6 +25080,15 @@ No pending questions found.`));
       const reason = args2.reason?.trim();
       supervisor.done = true;
       supervisor.paused = true;
+      const sessionsToAbort = Array.from(sessionMap.keys());
+      for (const id of sessionsToAbort) {
+        await client.session.abort({ path: { id } }).catch(() => {});
+        if (args2.delete_sessions) {
+          await client.session.delete({ path: { id } }).catch(() => {});
+        }
+      }
+      stopAllCommands("supervision-ended");
+      sessionMap.clear();
       supervisor.currentRalphSessionId = undefined;
       supervisor.currentWorkerSessionId = undefined;
       supervisor.activeReviewerName = undefined;
@@ -25451,6 +25509,8 @@ Set a new goal and run again.
     }
   });
   const emitHeartbeatWarnings = async () => {
+    if (supervisor.done || supervisor.paused)
+      return;
     const cfg = await run(getConfig());
     const thresholdMs = cfg.heartbeatMinutes * 60000;
     const now2 = Date.now();
@@ -25473,6 +25533,30 @@ Set a new goal and run again.
     await maybeWarn(supervisor.currentRalphSessionId, "Strategist");
     await maybeWarn(supervisor.currentWorkerSessionId, "Worker");
   };
+  const clearSessionTracking = async (sessionId, reason) => {
+    const st = sessionMap.get(sessionId);
+    sessionMap.delete(sessionId);
+    let didUpdate = false;
+    if (supervisor.currentRalphSessionId === sessionId) {
+      supervisor.currentRalphSessionId = undefined;
+      didUpdate = true;
+    }
+    if (supervisor.currentWorkerSessionId === sessionId) {
+      supervisor.currentWorkerSessionId = undefined;
+      didUpdate = true;
+    }
+    if (supervisor.activeReviewerSessionId === sessionId) {
+      supervisor.activeReviewerSessionId = undefined;
+      supervisor.activeReviewerName = undefined;
+      supervisor.activeReviewerAttempt = undefined;
+      supervisor.activeReviewerOutputPath = undefined;
+      didUpdate = true;
+      await persistReviewerState();
+    }
+    if (didUpdate && st) {
+      await notifySupervisor(`${st.role}/attempt-${st.attempt}`, `${st.role} session ended (${reason}).`, "info", true, sessionId);
+    }
+  };
   const runAndParseVerify = async () => {
     const raw = await run(runVerify(worktree));
     try {
@@ -25740,7 +25824,13 @@ ${templates.systemPromptAppend}` : base;
           getSession(sessionID);
       }
       if (event?.type === "session.status" && sessionID) {
+        if (supervisor.done || supervisor.paused)
+          return;
         const state = sessionMap.get(sessionID);
+        if (state?.role === "worker" && supervisor.currentWorkerSessionId !== sessionID)
+          return;
+        if (state?.role === "ralph" && supervisor.currentRalphSessionId !== sessionID)
+          return;
         if (state) {
           mutateSession(sessionID, (s) => {
             s.lastProgressAt = Date.now();
@@ -25752,6 +25842,8 @@ ${templates.systemPromptAppend}` : base;
         }
       }
       if (event?.type === "session.idle" && sessionID) {
+        if (supervisor.done || supervisor.paused)
+          return;
         await emitHeartbeatWarnings().catch((err) => {
           appLog("error", "heartbeat warning error", { error: String(err) });
         });
@@ -25769,6 +25861,9 @@ ${templates.systemPromptAppend}` : base;
           });
         }
       }
+      if (sessionID && (event?.type === "session.closed" || event?.type === "session.ended" || event?.type === "session.deleted")) {
+        await clearSessionTracking(sessionID, event.type);
+      }
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ralph-rlm",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "OpenCode plugin: Ralph outer loop + RLM inner loop. Iterative AI development with file-first discipline and sub-agent support.",
   "type": "module",
   "main": "./dist/ralph-rlm.js",