opencode-ralph-rlm 0.1.7 → 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. |
@@ -438,6 +439,9 @@ Bind the current session as the supervisor and optionally start attempt 1 immedi
 Stop supervision for the current process. This prevents further auto-loop orchestration until restarted.
 
 - 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()`
@@ -572,6 +576,16 @@ args:
   post_to_conversation boolean  optional  Post to main conversation (default: true)
 ```
 
+#### `ralph_peek_worker(maxLines?, post_to_conversation?)`
+
+Snapshot the active worker's `CURRENT_STATE.md` and optionally post it into the main conversation for quick "peek" access in the TUI.
+
+```
+args:
+  maxLines            number   optional  Max lines to include (default: 120)
+  post_to_conversation boolean optional  Post to main conversation (default: true)
+```
+
 #### `ralph_ask(question, context?, timeout_minutes?)`
 
 Ask a question and **block** until you respond via `ralph_respond()`. The question is written to `.opencode/pending_input.json`, a toast appears in the main session, and the main conversation is prompted with the question ID and response instruction. The calling session polls every 5 seconds.

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,
@@ -23509,6 +23512,7 @@ var DEFAULT_TEMPLATES = {
     "  When you receive one, call ralph_respond(id, answer) to unblock the session.",
     "- Use ralph_doctor() to check setup, ralph_bootstrap_plan() to generate PLAN/TODOS,",
     "  ralph_create_supervisor_session() to bind/start explicitly, ralph_pause_supervision()/ralph_resume_supervision() to control execution, and ralph_end_supervision() to stop.",
+    "- End supervision when verification has passed and the user confirms they are done, or when the user explicitly asks to stop the loop.",
     "- Optional reviewer flow: worker marks readiness with ralph_request_review(); supervisor runs ralph_run_reviewer().",
     "- Monitor progress in SUPERVISOR_LOG.md, CONVERSATION.md, or via toast notifications."
   ].join(`
@@ -23761,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,
@@ -23771,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);
     });
@@ -23778,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() });
     });
   });
 }
@@ -24102,7 +24149,21 @@ var RalphRLM = async ({ client, $, worktree }) => {
 - ${nowISO()} rotated
 `)).catch(() => {});
   };
+  const DEDUPE_WINDOW_MS = 5000;
+  const recentNotices = new Map;
+  const shouldDedupe = (key) => {
+    const now2 = Date.now();
+    const last3 = recentNotices.get(key);
+    if (last3 && now2 - last3 < DEDUPE_WINDOW_MS)
+      return true;
+    if (recentNotices.size > 200)
+      recentNotices.clear();
+    recentNotices.set(key, now2);
+    return false;
+  };
   const appendConversationEntry = async (source, message) => {
+    if (shouldDedupe(`conv|${source}|${message}`))
+      return;
     const cfg = await run(getConfig());
     await rotateConversationLogIfNeeded(cfg);
     const ts = nowISO();
@@ -24113,6 +24174,8 @@ var RalphRLM = async ({ client, $, worktree }) => {
     });
   };
   const notifySupervisor = async (source, message, level = "info", postToConversation = true, originSessionId) => {
+    if (shouldDedupe(`sup|${source}|${level}|${message}`))
+      return;
     const cfg = await run(getConfig());
     if (!messagePassesVerbosity(cfg.statusVerbosity, level))
       return;
@@ -24137,6 +24200,34 @@ var RalphRLM = async ({ client, $, worktree }) => {
       }).catch(() => {});
     }
   };
+  const detectProjectDefaults = (root) => exports_Effect.gen(function* () {
+    const j = (f) => NodePath.join(root, f);
+    const hasBunLock = (yield* fileExists(j("bun.lockb"))) || (yield* fileExists(j("bun.lock")));
+    if (hasBunLock)
+      return { verify: ["bun", "run", "verify"], install: "bun install" };
+    const hasYarnLock = yield* fileExists(j("yarn.lock"));
+    if (hasYarnLock)
+      return { verify: ["yarn", "test"], install: "yarn install" };
+    const hasPnpmLock = yield* fileExists(j("pnpm-lock.yaml"));
+    if (hasPnpmLock)
+      return { verify: ["pnpm", "test"], install: "pnpm install" };
+    const hasPkg = yield* fileExists(j("package.json"));
+    if (hasPkg)
+      return { verify: ["npm", "test"], install: "npm install" };
+    const hasCargo = yield* fileExists(j("Cargo.toml"));
+    if (hasCargo)
+      return { verify: ["cargo", "test"], install: "cargo build" };
+    const hasPy = yield* fileExists(j("pyproject.toml"));
+    const hasReq = yield* fileExists(j("requirements.txt"));
+    if (hasReq)
+      return { verify: ["python", "-m", "pytest"], install: "pip install -r requirements.txt" };
+    if (hasPy)
+      return { verify: ["python", "-m", "pytest"], install: "pip install ." };
+    const hasMake = yield* fileExists(j("Makefile"));
+    if (hasMake)
+      return { verify: ["make", "test"], install: "make" };
+    return { verify: ["bun", "run", "verify"], install: "bun install" };
+  });
   const checkSetup = async (root, cfg) => {
     const diagnostics = {
       ready: true,
@@ -24148,7 +24239,8 @@ var RalphRLM = async ({ client, $, worktree }) => {
     if (!cfg.verify || cfg.verify.command.length === 0) {
       diagnostics.ready = false;
       diagnostics.issues.push("Missing verify.command in .opencode/ralph.json.");
-      diagnostics.suggestions.push('Set verify.command, e.g. ["bun", "run", "verify"].');
+      const defaults = await run(detectProjectDefaults(root));
+      diagnostics.suggestions.push(`Set verify.command, e.g. ${JSON.stringify(defaults.verify)}.`);
     }
     const planExists = await run(fileExists(j(FILES.PLAN)));
     if (!planExists) {
@@ -24249,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);
         }
@@ -24502,6 +24596,41 @@ ${args2.nextStep}
       return run(runVerify(root));
     }
   });
+  const tool_ralph_peek_worker = tool({
+    description: "Snapshot the active RLM worker's CURRENT_STATE.md and optionally post it into the main conversation.",
+    args: {
+      maxLines: tool.schema.number().int().min(20).max(400).optional(),
+      post_to_conversation: tool.schema.boolean().optional().describe("Whether to post the peek into the main conversation (default: true).")
+    },
+    async execute(args2, ctx) {
+      const root = ctx.worktree ?? worktree;
+      const currPath = NodePath.join(root, FILES.CURR);
+      const ok = await run(fileExists(currPath));
+      if (!ok)
+        return JSON.stringify({ ok: false, missing: FILES.CURR }, null, 2);
+      const raw = await run(readFile(currPath).pipe(exports_Effect.orElseSucceed(() => "")));
+      const text = clampLines(raw, args2.maxLines ?? 120);
+      const attempt = supervisor.attempt;
+      const workerId = supervisor.currentWorkerSessionId;
+      const header = `Worker peek${attempt ? ` (attempt ${attempt})` : ""}${workerId ? ` \u2014 ${workerId}` : ""}`;
+      await notifySupervisor("peek", header, "info", false, ctx.sessionID);
+      const postToConv = args2.post_to_conversation !== false;
+      if (postToConv && supervisor.sessionId && supervisor.sessionId !== ctx.sessionID) {
+        await client.session.promptAsync({
+          path: { id: supervisor.sessionId },
+          body: { parts: [{ type: "text", text: `[peek] ${header}
+
+${text}` }] }
+        }).catch(() => {});
+      }
+      return JSON.stringify({
+        ok: true,
+        attempt: attempt || null,
+        workerSessionId: workerId ?? null,
+        text
+      }, null, 2);
+    }
+  });
   const tool_subagent_peek = tool({
     description: "Read file-first state from a sub-agent directory (.opencode/agents/<name>/).",
     args: {
@@ -24777,6 +24906,7 @@ No pending questions found.`));
       const diagnosticsBefore = await checkSetup(root, cfg);
       const actions = [];
       if (args2.autofix) {
+        const defaults = await run(detectProjectDefaults(root));
         const configPath = NodePath.join(root, ".opencode", "ralph.json");
         const configExists = await run(fileExists(configPath));
         if (!configExists) {
@@ -24786,7 +24916,7 @@ No pending questions found.`));
             statusVerbosity: "normal",
             maxAttempts: 25,
             heartbeatMinutes: 15,
-            verify: { command: ["bun", "run", "verify"], cwd: "." },
+            verify: { command: defaults.verify, cwd: "." },
             gateDestructiveToolsUntilContextLoaded: true,
             maxRlmSliceLines: 200,
             requireGrepBeforeLargeSlice: true,
@@ -24814,8 +24944,8 @@ No pending questions found.`));
             "# Project Agent Rules",
             "",
             "## Build and verify",
-            "- Install: bun install",
-            "- Verify: bun run verify",
+            `- Install: ${defaults.install}`,
+            `- Verify: ${defaults.verify.join(" ")}`,
             "",
             "## Loop note",
             "- This project uses ralph-rlm.",
@@ -24942,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) {
@@ -24949,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;
@@ -25149,13 +25289,14 @@ Set a new goal and run again.
         const configPath = NodePath.join(root, ".opencode", "ralph.json");
         const configExists = await run(fileExists(configPath));
         if (!configExists) {
+          const defaults = await run(detectProjectDefaults(root));
           const defaultCfg = {
             enabled: true,
             autoStartOnMainIdle: false,
             statusVerbosity: "normal",
             maxAttempts: 25,
             heartbeatMinutes: 15,
-            verify: { command: ["bun", "run", "verify"], cwd: "." },
+            verify: { command: defaults.verify, cwd: "." },
             gateDestructiveToolsUntilContextLoaded: true,
             maxRlmSliceLines: 200,
             requireGrepBeforeLargeSlice: true,
@@ -25368,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();
@@ -25390,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 {
@@ -25592,6 +25759,7 @@ ${interpolate(templates.continuePrompt, { attempt: String(attemptN), verdict })}
       ralph_update_rlm_instructions: tool_ralph_update_rlm_instructions,
       ralph_rollover: tool_ralph_rollover,
       ralph_verify: tool_ralph_verify,
+      ralph_peek_worker: tool_ralph_peek_worker,
       ralph_spawn_worker: tool_ralph_spawn_worker,
       subagent_peek: tool_subagent_peek,
       subagent_spawn: tool_subagent_spawn,
@@ -25656,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();
@@ -25668,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) });
         });
@@ -25685,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.7",
+  "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",