opencode-ralph-rlm 0.1.13 → 0.1.14

package/README.md

@@ -6,8 +6,8 @@ New here? Start with [`GETTINGSTARTEDGUIDE.md`](GETTINGSTARTEDGUIDE.md).
 
 Two techniques combine to make this work:
 
-- **Ralph** — a strategist session spawned fresh per attempt. It reviews what failed, adjusts the plan and instructions, then delegates coding to a worker. It never writes code itself.
-- **RLM** (Recursive Language Model worker) — a file-first coding session based on [arXiv:2512.24601](https://arxiv.org/abs/2512.24601). Each attempt gets a clean context window and loads all state from files rather than inheriting noise from prior turns.
+- **Ralph** - the main session acting as strategist+supervisor. It reviews what failed, adjusts the plan and instructions, then delegates coding to a worker. It never writes code itself.
+- **RLM** (Recursive Language Model worker) - a file-first coding session based on [arXiv:2512.24601](https://arxiv.org/abs/2512.24601). Each attempt gets a clean context window and loads all state from files rather than inheriting noise from prior turns.
 
 
 ## The problem this solves
@@ -43,9 +43,9 @@ Context windows are session-local and finite. Files are persistent, inspectable,
 
 ### Separation of strategy and execution
 
-The Ralph strategist session exists because mixing strategy and execution in the same context is how reasoning degrades. When a session that just wrote failing code is also responsible for diagnosing *why* it failed and planning the next approach, it pattern-matches against its own failed reasoning. It proposes variations on what didn't work rather than stepping back.
+Ralph keeps strategy and execution separate: **you (main session)** handle strategy and delegation, while **workers** implement. When a session that just wrote failing code is also responsible for diagnosing *why* it failed and planning the next approach, it pattern-matches against its own failed reasoning. It proposes variations on what didn't work rather than stepping back.
 
-Ralph's session gets a fresh window. It reads the failure record cold, without the accumulated baggage of having written the code. This mirrors how experienced engineering teams work: the reviewer of a failing PR is often not the one who writes the fix.
+In this mode, the *worker* always gets a fresh window. It reads the failure record cold, without the accumulated baggage of having written the code. This mirrors how experienced engineering teams work: the reviewer of a failing PR is often not the one who writes the fix.
 
 ### The verify contract
 
@@ -63,52 +63,48 @@ The RLM paper demonstrates that full-file reads are expensive and often counterp
 
 `NOTES_AND_LEARNINGS.md` and `RLM_INSTRUCTIONS.md` are the loop's long-term memory. They survive context resets and accumulate across attempts. The loop doesn't just retry — it gets smarter with each failure.
 
-`RLM_INSTRUCTIONS.md` is the inner loop's operating manual. The Ralph strategist updates it between attempts when a pattern of failures reveals a gap in guidance. By attempt 10, the instructions encode everything learned from attempts 1-9.
+`RLM_INSTRUCTIONS.md` is the inner loop's operating manual. The main strategist (you) updates it between attempts when a pattern of failures reveals a gap in guidance. By attempt 10, the instructions encode everything learned from attempts 1-9.
 
 This is why the approach scales to overnight runs. A fresh worker in attempt 10 starts with the accumulated knowledge of 9 prior attempts, encoded in protocol files, without the accumulated noise.
 
 
 ## How it works
 
-### Three-level architecture
+### Two-level architecture (main session = strategist + supervisor)
 
 ```
-You → main session (thin meta-supervisor — your conversation)
+You → main session (supervisor + strategist in one)
          │
          ├─ attempt 1:
-         │    ├─ spawns Ralph strategist session R1  ← fresh context
-         │    │    R1: ralph_load_context() → review failures → update PLAN.md
-         │    │        → ralph_spawn_worker() → STOP
+         │    ├─ strategist (you): ralph_load_context() → review failures → update PLAN.md
+         │    ├─ ralph_spawn_worker() → spawns RLM worker session W1
          │    │
-         │    └─ spawns RLM worker session W1  ← fresh context
+         │    └─ RLM worker session W1  ← fresh context
          │         W1: ralph_load_context() → code → ralph_verify() → STOP
          │
          ├─ plugin verifies on W1 idle
          │    fail → roll state files → spawn attempt 2
          │
          ├─ attempt 2:
-         │    ├─ spawns Ralph strategist session R2  ← fresh context again
-         │    │    R2: reads AGENT_CONTEXT_FOR_NEXT_RALPH.md → adjusts strategy
-         │    │        → ralph_spawn_worker() → STOP
+         │    ├─ strategist (you): reads AGENT_CONTEXT_FOR_NEXT_RALPH.md → adjusts strategy
+         │    ├─ ralph_spawn_worker() → spawns RLM worker session W2
          │    │
-         │    └─ spawns RLM worker session W2  ← fresh context
+         │    └─ RLM worker session W2  ← fresh context
          │         W2: loads compact state from files → code → STOP
          │
          └─ pass → done toast
 ```
 
-Each session role has a distinct purpose and **fresh context window**:
+Each role has a distinct purpose and **fresh context window** where applicable:
 
 | Role | Session | Context | Responsibility |
 |---|---|---|---|
-| **main** | Your conversation | Persistent | Goal → stop. Plugin handles the rest. |
-| **ralph** | Per-attempt strategist | Fresh | Review failure, update PLAN.md / RLM_INSTRUCTIONS.md, call `ralph_spawn_worker()`. |
+| **main** | Your conversation | Persistent | Supervisor + strategist. Review failures, update PLAN.md / RLM_INSTRUCTIONS.md, call `ralph_spawn_worker()`. |
 | **worker** | Per-attempt coder | Fresh | `ralph_load_context()` → code → `ralph_verify()` → stop. |
 
 ### Roles and responsibilities (quick map)
 
-- **Supervisor (main session):** orchestration and decisions only. Never edits files or runs code; uses `ralph_*` tools to control lifecycle.
-- **Ralph strategist:** updates plan/instructions and delegates to a worker. No direct implementation.
+- **Supervisor+strategist (main session):** orchestration, planning, and delegation. Never edits files or runs code directly.
 - **RLM worker:** does the actual coding and verification for this attempt. One pass per session.
 - **Sub-agent:** narrow task helper; updates its own state files under `.opencode/agents/<name>/`.
 
@@ -116,15 +112,13 @@ Each session role has a distinct purpose and **fresh context window**:
 
 ```
 main idle
-  └─ spawn Ralph(1)
-       └─ Ralph(1) calls ralph_spawn_worker()
-            └─ spawn Worker(1)
-                 └─ Worker(1) calls ralph_verify() and goes idle
-                      └─ plugin runs verify
-                           ├─ pass → done
-                           └─ fail → roll state files
-                                └─ spawn Ralph(2)
-                                     └─ (repeat)
+  └─ strategist (you) calls ralph_spawn_worker()
+       └─ spawn Worker(1)
+            └─ Worker(1) calls ralph_verify() and goes idle
+                 └─ plugin runs verify
+                      ├─ pass → done
+                      └─ fail → roll state files
+                           └─ strategist (you) handles next attempt
 ```
 
 The plugin drives the loop from `session.idle` events. Neither Ralph nor the worker need to know about the outer loop — they just load context, do their job, and stop.
@@ -295,7 +289,7 @@ This repo now includes project-local agent files under `.opencode/agents/`:
 - `.opencode/agents/security-auditor.md`
 
 These profiles intentionally keep loop ownership in `ralph-rlm`.
-Do not model Ralph strategist/worker as OpenCode primary/subagent replacements.
+Do not model the strategist/worker roles as OpenCode primary/subagent replacements.
 
 
 ## Protocol files
@@ -524,9 +518,9 @@ Run the configured verify command. Returns `{ verdict: "pass"|"fail"|"unknown",
 
 #### `ralph_spawn_worker()`
 
-**Ralph strategist sessions only.** Spawn a fresh RLM worker session for this attempt. Call this after reviewing protocol files and optionally updating `PLAN.md` / `RLM_INSTRUCTIONS.md`. Then stop — the plugin handles verification and spawns the next Ralph session if needed.
+**Main strategist only.** Spawn a fresh RLM worker session for this attempt. Call this after reviewing protocol files and optionally updating `PLAN.md` / `RLM_INSTRUCTIONS.md`. Then stop — the plugin handles verification and prompts you for the next attempt if needed.
 
-If you call this from the main conversation you will get: `ralph_spawn_worker() can only be called from a Ralph strategist session.` In normal operation the plugin creates strategist sessions automatically on `session.idle`.
+If you call this from an unbound session you will get: `ralph_spawn_worker() must be called from the bound supervisor session.` Bind first with `ralph_create_supervisor_session()`.
 
 ### Sub-agents
 
@@ -548,7 +542,7 @@ List all sub-agents registered in the current session with their name, goal, sta
 
 ### Supervisor communication
 
-These tools let spawned sessions (Ralph strategist, RLM worker) communicate back to the main conversation at runtime. State is carried in `.opencode/pending_input.json` for question/response pairs, `SUPERVISOR_LOG.md` for structured status entries, and `CONVERSATION.md` for the readable event timeline.
+These tools let spawned sessions (RLM worker + sub-agents) communicate back to the main conversation at runtime. State is carried in `.opencode/pending_input.json` for question/response pairs, `SUPERVISOR_LOG.md` for structured status entries, and `CONVERSATION.md` for the readable event timeline.
 
 User answers to `ralph_ask()` are persisted too: when you reply via `ralph_respond()`, the response is appended to `CONVERSATION.md`.
 
@@ -655,8 +649,8 @@ RALPH_BOOTSTRAP_RLM_INSTRUCTIONS="@/home/user/prompts/rlm-instructions.md"
 | `RALPH_CONTEXT_GATE_ERROR` | — | Error message thrown when the agent tries a destructive tool before loading context. |
 | `RALPH_WORKER_SYSTEM_PROMPT` | — | System prompt injected into every RLM worker session. Describes the one-pass contract. |
 | `RALPH_WORKER_PROMPT` | `{{attempt}}` | Initial prompt sent to each spawned RLM worker session. |
-| `RALPH_SESSION_SYSTEM_PROMPT` | — | System prompt injected into Ralph strategist sessions. |
-| `RALPH_SESSION_PROMPT` | `{{attempt}}` | Initial prompt sent to each spawned Ralph strategist session. |
+| `RALPH_SESSION_SYSTEM_PROMPT` | — | Legacy: system prompt for separate strategist sessions (unused in main-as-strategist mode). |
+| `RALPH_SESSION_PROMPT` | `{{attempt}}` | Prompt sent to the main strategist session when an attempt starts. |
 
 ### Example: custom continue prompt from a file
 
@@ -699,7 +693,7 @@ Set `maxAttempts` high (25–50), write a detailed `PLAN.md` with a precise defi
 
 1. Make an attempt.
 2. Run verify.
-3. On failure: roll state, spawn Ralph to diagnose and adjust, spawn the next worker.
+3. On failure: roll state, prompt the strategist (you) to diagnose and adjust, spawn the next worker.
 4. Repeat until it passes or hits `maxAttempts`.
 
 In the morning, check `SUPERVISOR_LOG.md` and `CONVERSATION.md` for the progress feed, `NOTES_AND_LEARNINGS.md` for what the loop learned, and `AGENT_CONTEXT_FOR_NEXT_RALPH.md` for where it stopped.
@@ -746,19 +740,19 @@ Parent agent:
 
 Edit `RLM_INSTRUCTIONS.md` to add project-specific playbooks, register MCP tools, or adjust the debug workflow. Changes persist across attempts. Use `ralph_update_rlm_instructions()` from within a session, or edit the file directly.
 
-The instructions file is the primary lever for improving loop performance. If the loop keeps making the same mistake, add a rule. If it keeps following an inefficient path, add a playbook. The Ralph strategist is responsible for updating these instructions between attempts based on what it observes in the failure record.
+The instructions file is the primary lever for improving loop performance. If the loop keeps making the same mistake, add a rule. If it keeps following an inefficient path, add a playbook. The main strategist (you) updates these instructions between attempts based on what it observes in the failure record.
 
 
 ## Hooks installed
 
 | Hook | What it does |
 |---|---|
-| `event: session.idle` | Routes idle events: **worker** → `handleWorkerIdle` (verify + continue loop); **ralph** → `handleRalphSessionIdle` (warn if no worker spawned); **main/other** → `handleMainIdle` (kick off attempt 1). Also emits heartbeat/staleness warnings and supervisor status updates to `SUPERVISOR_LOG.md` and `CONVERSATION.md`. |
-| `event: session.created` | Pre-allocates session state for known worker/ralph sessions. |
+| `event: session.idle` | Routes idle events: **worker** → `handleWorkerIdle` (verify + continue loop); **main/other** → `handleMainIdle` (kick off attempt 1). Also emits heartbeat/staleness warnings and supervisor status updates to `SUPERVISOR_LOG.md` and `CONVERSATION.md`. |
+| `event: session.created` | Pre-allocates session state for known worker sessions. |
 | `event: session.status` | Refreshes heartbeat/progress timestamps for active sessions and surfaces explicit session error statuses to the supervisor feed. |
-| `experimental.chat.system.transform` | Three-way routing: **worker** → RLM file-first prompt; **ralph** → Ralph strategist prompt; **main/other** → supervisor prompt. |
+| `experimental.chat.system.transform` | Two-way routing: **worker** → RLM file-first prompt; **main/other** → supervisor+strategist prompt. |
 | `experimental.session.compacting` | Injects protocol file pointers into compaction context so state survives context compression. |
-| `tool.execute.before` | Blocks destructive tools (`write`, `edit`, `bash`, `delete`, `move`, `rename`) in **worker and sub-agent sessions** until `ralph_load_context()` has been called. Ralph strategist sessions are not gated. |
+| `tool.execute.before` | Blocks destructive tools (`write`, `edit`, `bash`, `delete`, `move`, `rename`) in **worker and sub-agent sessions** until `ralph_load_context()` has been called. |
 
 
 ## Background
@@ -767,7 +761,7 @@ The instructions file is the primary lever for improving loop performance. If th
 
 The outer loop is named after the [Ralph Wiggum technique](https://www.geoffreyhuntley.com/ralph) — a `while` loop that feeds a prompt to an AI agent until it succeeds. The name reflects the philosophy: persistent, not clever. The loop doesn't try to be smart about when to give up. It tries, records what happened, and tries again with better instructions.
 
-The key addition in this plugin over a naive Ralph implementation is the **separation of the strategist from the worker**. A naive loop re-prompts the same session. This plugin spawns a fresh Ralph strategist to review the failure before spawning the next worker. The strategist's fresh context means it analyses the failure without being anchored to the reasoning that produced it.
+The key addition in this plugin over a naive Ralph implementation is the **separation of the strategist from the worker**. The main session handles strategy and delegation, while each worker gets a fresh context to implement. This keeps planning clean while still benefiting from fresh worker windows.
 
 ### The RLM inner loop
 

package/dist/ralph-rlm.js

@@ -23510,9 +23510,9 @@ var DEFAULT_TEMPLATES = {
   systemPrompt: [
     "RALPH SUPERVISOR:",
     "- You are the Ralph supervisor. You orchestrate RLM worker sessions; you do NOT write code yourself.",
-    "- When the user gives you a goal, describe the task briefly and stop \u2014 the plugin will spawn an RLM worker automatically.",
-    "- You are NOT the Ralph strategist and NOT the RLM worker. Those are separate sessions.",
-    "  Supervisor = orchestration + decisions; Ralph strategist = planning + delegation; RLM worker = implementation.",
+    "- When the user gives you a goal, describe the task briefly and then act as the strategist: call ralph_spawn_worker() to hand off.",
+    "- You ARE the strategist in the main session, and you are NOT the RLM worker.",
+    "  Supervisor+strategist = orchestration + planning + delegation; RLM worker = implementation.",
     "- Workers are spawned per-attempt with a fresh context window. They load state from protocol files.",
     "- Protocol files (PLAN.md, RLM_INSTRUCTIONS.md, etc.) persist across all attempts \u2014 edit them to guide workers.",
     "- After each worker attempt the plugin runs verify and either finishes or spawns the next worker.",
@@ -24290,6 +24290,49 @@ var RalphRLM = async ({ client, $, worktree }) => {
       return false;
     }
   };
+  const promptStrategistInMain = async (attempt) => {
+    if (!supervisor.sessionId) {
+      await notifySupervisor("supervisor", "Cannot prompt strategist: supervisor session not bound. Run ralph_create_supervisor_session().", "warning", true);
+      return;
+    }
+    supervisor.awaitingStrategist = true;
+    if (supervisor.ralphHandoffAttempt !== attempt) {
+      supervisor.ralphHandoffAttempt = attempt;
+      supervisor.ralphHandoffRetries = 0;
+    }
+    const promptText = interpolate(templates.ralphSessionPrompt, {
+      attempt: String(attempt),
+      nextAttempt: String(attempt + 1)
+    });
+    const ok = await sendPromptWithFallback(supervisor.sessionId, promptText, `Strategist prompt (attempt ${attempt})`, supervisor.sessionId);
+    if (!ok) {
+      supervisor.paused = true;
+      await notifySupervisor(`supervisor/attempt-${attempt}`, "Strategist prompt failed; supervision paused. Retry with ralph_create_supervisor_session(restart_if_done=true).", "error", true, supervisor.sessionId);
+      return;
+    }
+    if (supervisor.ralphHandoffTimer) {
+      clearTimeout(supervisor.ralphHandoffTimer);
+    }
+    const cfg = await run(getConfig());
+    const timeoutMs = Math.max(cfg.strategistHandoffMinutes, 1) * 60000;
+    supervisor.ralphHandoffTimer = setTimeout(async () => {
+      if (supervisor.done || supervisor.paused)
+        return;
+      if (!supervisor.awaitingStrategist)
+        return;
+      if (supervisor.ralphHandoffAttempt !== attempt)
+        return;
+      const retries = supervisor.ralphHandoffRetries ?? 0;
+      if (retries < cfg.strategistHandoffMaxRetries) {
+        supervisor.ralphHandoffRetries = retries + 1;
+        await notifySupervisor(`supervisor/attempt-${attempt}`, `Strategist did not hand off; re-prompting main session (${retries + 1}/${cfg.strategistHandoffMaxRetries}).`, "warning", true, supervisor.sessionId);
+        await promptStrategistInMain(attempt);
+        return;
+      }
+      await notifySupervisor(`supervisor/attempt-${attempt}`, "Strategist did not hand off after retries; supervision paused. Use ralph_create_supervisor_session(restart_if_done=true) to retry.", "error", true, supervisor.sessionId);
+      supervisor.paused = true;
+    }, timeoutMs);
+  };
   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")));
@@ -25133,7 +25176,7 @@ No pending questions found.`));
       if (supervisor.done && args2.restart_if_done === true) {
         supervisor.done = false;
         supervisor.paused = false;
-        supervisor.currentRalphSessionId = undefined;
+        supervisor.awaitingStrategist = false;
         supervisor.currentWorkerSessionId = undefined;
         supervisor.activeReviewerName = undefined;
         supervisor.activeReviewerAttempt = undefined;
@@ -25142,19 +25185,19 @@ No pending questions found.`));
         await persistReviewerState();
         await notifySupervisor("supervisor", "Supervisor done-state reset for a new run.", "info", true, sessionID);
       }
-      if (supervisor.currentRalphSessionId || supervisor.currentWorkerSessionId || supervisor.done) {
+      if (supervisor.currentWorkerSessionId || supervisor.done) {
         return JSON.stringify({
           ok: true,
           started: false,
           message: "Loop is already running or completed for this process.",
-          currentRalphSessionId: supervisor.currentRalphSessionId,
           currentWorkerSessionId: supervisor.currentWorkerSessionId,
           done: supervisor.done
         }, null, 2);
       }
       supervisor.attempt = 1;
+      supervisor.awaitingStrategist = false;
       await notifySupervisor("supervisor", "Starting Ralph loop at attempt 1 (manual start).", "info", true, sessionID);
-      await spawnRalphSession(1);
+      await promptStrategistInMain(1);
       return JSON.stringify({ ok: true, started: true, attempt: 1 }, null, 2);
     }
   });
@@ -25170,6 +25213,7 @@ No pending questions found.`));
       const reason = args2.reason?.trim();
       supervisor.done = true;
       supervisor.paused = true;
+      supervisor.awaitingStrategist = false;
       const sessionsToAbort = Array.from(sessionMap.keys());
       for (const id of sessionsToAbort) {
         await client.session.abort({ path: { id } }).catch(() => {});
@@ -25179,7 +25223,6 @@ No pending questions found.`));
       }
       stopAllCommands("supervision-ended");
       sessionMap.clear();
-      supervisor.currentRalphSessionId = undefined;
       supervisor.currentWorkerSessionId = undefined;
       supervisor.activeReviewerName = undefined;
       supervisor.activeReviewerAttempt = undefined;
@@ -25203,7 +25246,7 @@ No pending questions found.`));
     }
   });
   const tool_ralph_supervision_status = tool({
-    description: "Get current supervision state (binding, attempt, active strategist/worker, done flag).",
+    description: "Get current supervision state (binding, attempt, awaiting strategist/worker, done flag).",
     args: {},
     async execute(_args, _ctx) {
       return JSON.stringify({
@@ -25212,7 +25255,7 @@ No pending questions found.`));
           attempt: supervisor.attempt,
           done: supervisor.done,
           paused: supervisor.paused ?? false,
-          currentRalphSessionId: supervisor.currentRalphSessionId ?? null,
+          awaitingStrategist: supervisor.awaitingStrategist ?? false,
           currentWorkerSessionId: supervisor.currentWorkerSessionId ?? null,
           activeReviewerName: supervisor.activeReviewerName ?? null,
           activeReviewerAttempt: supervisor.activeReviewerAttempt ?? null,
@@ -25258,11 +25301,11 @@ No pending questions found.`));
           message: "Loop is marked done. Use ralph_create_supervisor_session(restart_if_done=true)."
         }, null, 2);
       }
-      if (supervisor.currentRalphSessionId || supervisor.currentWorkerSessionId) {
+      if (supervisor.currentWorkerSessionId) {
         return JSON.stringify({ ok: true, resumed: true, started: false, message: "Loop already running." }, null, 2);
       }
       supervisor.attempt = Math.max(1, supervisor.attempt || 1);
-      await spawnRalphSession(supervisor.attempt);
+      await promptStrategistInMain(supervisor.attempt);
       return JSON.stringify({ ok: true, resumed: true, started: true, attempt: supervisor.attempt }, null, 2);
     }
   });
@@ -25348,8 +25391,14 @@ Set a new goal and run again.
       supervisor.done = false;
       supervisor.paused = false;
       supervisor.attempt = 0;
-      supervisor.currentRalphSessionId = undefined;
       supervisor.currentWorkerSessionId = undefined;
+      supervisor.awaitingStrategist = false;
+      supervisor.ralphHandoffRetries = 0;
+      supervisor.ralphHandoffAttempt = undefined;
+      if (supervisor.ralphHandoffTimer) {
+        clearTimeout(supervisor.ralphHandoffTimer);
+        supervisor.ralphHandoffTimer = undefined;
+      }
       supervisor.activeReviewerName = undefined;
       supervisor.activeReviewerAttempt = undefined;
       supervisor.activeReviewerSessionId = undefined;
@@ -25439,7 +25488,7 @@ Set a new goal and run again.
         supervisor.done = false;
         supervisor.paused = false;
         supervisor.attempt = 1;
-        await spawnRalphSession(1);
+        await promptStrategistInMain(1);
         actions.push("Started loop at attempt 1");
       }
       await appendConversationEntry("supervisor", `Quickstart completed for goal: ${args2.goal}`);
@@ -25624,18 +25673,12 @@ Set a new goal and run again.
         s.lastProgressAt = now2;
       });
     };
-    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;
-    const clearedRalph = supervisor.currentRalphSessionId === sessionId;
-    if (clearedRalph) {
-      supervisor.currentRalphSessionId = undefined;
-      didUpdate = true;
-    }
     if (supervisor.currentWorkerSessionId === sessionId) {
       supervisor.currentWorkerSessionId = undefined;
       didUpdate = true;
@@ -25648,7 +25691,7 @@ Set a new goal and run again.
       didUpdate = true;
       await persistReviewerState();
     }
-    if (supervisor.ralphHandoffTimer && clearedRalph) {
+    if (supervisor.ralphHandoffTimer && supervisor.sessionId === sessionId) {
       clearTimeout(supervisor.ralphHandoffTimer);
       supervisor.ralphHandoffTimer = undefined;
     }
@@ -25730,77 +25773,30 @@ ${interpolate(templates.continuePrompt, { attempt: String(attemptN), verdict })}
   tool_ralph_spawn_worker_impl = async (_args, ctx) => {
     const sessionID = ctx.sessionID ?? "";
     const st = sessionMap.get(sessionID);
-    if (st?.role !== "ralph") {
-      throw new Error("ralph_spawn_worker() can only be called from a Ralph strategist session.");
+    const isMainStrategist = st?.role === "main";
+    if (!isMainStrategist && st?.role !== "ralph") {
+      throw new Error("ralph_spawn_worker() must be called from the main strategist session.");
     }
-    if (st.workerSpawned) {
-      throw new Error("ralph_spawn_worker() has already been called for this attempt.");
+    if (isMainStrategist && supervisor.sessionId && supervisor.sessionId !== sessionID) {
+      throw new Error("ralph_spawn_worker() must be called from the bound supervisor session.");
+    }
+    if (supervisor.attempt < 1) {
+      throw new Error("No active attempt. Start with ralph_create_supervisor_session(start_loop=true).");
     }
     if (supervisor.ralphHandoffTimer) {
       clearTimeout(supervisor.ralphHandoffTimer);
       supervisor.ralphHandoffTimer = undefined;
     }
-    const workerId = await spawnRlmWorker(st.attempt);
+    supervisor.awaitingStrategist = false;
+    const attempt = isMainStrategist ? supervisor.attempt : st.attempt;
+    const workerId = await spawnRlmWorker(attempt);
     mutateSession(sessionID, (s) => {
       s.workerSpawned = true;
     });
     supervisor.ralphHandoffRetries = 0;
-    supervisor.ralphHandoffAttempt = st.attempt;
-    await notifySupervisor(`ralph/attempt-${st.attempt}`, `Delegated coding to worker session ${workerId}.`, "info", true, sessionID);
-    return JSON.stringify({ ok: true, workerSessionId: workerId, attempt: st.attempt }, null, 2);
-  };
-  const spawnRalphSession = async (attempt) => {
-    const result = await client.session.create({
-      body: { title: `ralph-strategist-attempt-${attempt}` }
-    });
-    const ralphId = result.data?.id ?? `ralph-${Date.now()}`;
-    if (supervisor.ralphHandoffAttempt !== attempt) {
-      supervisor.ralphHandoffAttempt = attempt;
-      supervisor.ralphHandoffRetries = 0;
-    }
-    supervisor.currentRalphSessionId = ralphId;
-    sessionMap.set(ralphId, freshSession("ralph", attempt));
-    mutateSession(ralphId, (s) => {
-      s.lastProgressAt = Date.now();
-    });
-    const promptText = interpolate(templates.ralphSessionPrompt, {
-      attempt: String(attempt),
-      nextAttempt: String(attempt + 1)
-    });
-    const promptOk = await sendPromptWithFallback(ralphId, promptText, `Strategist prompt (attempt ${attempt})`, ralphId);
-    if (!promptOk) {
-      supervisor.currentRalphSessionId = undefined;
-      await client.session.abort({ path: { id: ralphId } }).catch(() => {});
-      await notifySupervisor(`supervisor/attempt-${attempt}`, "Strategist prompt failed; supervision paused. Retry with ralph_create_supervisor_session(restart_if_done=true).", "error", true);
-      supervisor.paused = true;
-      return;
-    }
-    if (supervisor.ralphHandoffTimer) {
-      clearTimeout(supervisor.ralphHandoffTimer);
-    }
-    const cfg = await run(getConfig());
-    const timeoutMs = Math.max(cfg.strategistHandoffMinutes, 1) * 60000;
-    supervisor.ralphHandoffTimer = setTimeout(async () => {
-      if (supervisor.done || supervisor.paused)
-        return;
-      if (supervisor.currentRalphSessionId !== ralphId)
-        return;
-      const st = sessionMap.get(ralphId);
-      if (st?.workerSpawned)
-        return;
-      const retries = supervisor.ralphHandoffRetries ?? 0;
-      if (retries < cfg.strategistHandoffMaxRetries) {
-        supervisor.ralphHandoffRetries = retries + 1;
-        await notifySupervisor(`ralph/attempt-${attempt}`, `Strategist did not hand off; retrying strategist (${retries + 1}/${cfg.strategistHandoffMaxRetries}).`, "warning", true, ralphId);
-        supervisor.currentRalphSessionId = undefined;
-        await client.session.abort({ path: { id: ralphId } }).catch(() => {});
-        await spawnRalphSession(attempt);
-        return;
-      }
-      await notifySupervisor(`ralph/attempt-${attempt}`, "Strategist did not hand off after retries; supervision paused. Use ralph_create_supervisor_session(restart_if_done=true) to retry.", "error", true, ralphId);
-      supervisor.paused = true;
-    }, timeoutMs);
-    await notifySupervisor(`supervisor/attempt-${attempt}`, `Spawned Ralph strategist session ${ralphId}.`, "info", true);
+    supervisor.ralphHandoffAttempt = attempt;
+    await notifySupervisor(`supervisor/attempt-${attempt}`, `Delegated coding to worker session ${workerId}.`, "info", true, sessionID);
+    return JSON.stringify({ ok: true, workerSessionId: workerId, attempt }, null, 2);
   };
   const handleWorkerIdle = async (workerSessionId) => {
     if (supervisor.currentWorkerSessionId !== workerSessionId)
@@ -25819,6 +25815,11 @@ ${interpolate(templates.continuePrompt, { attempt: String(attemptN), verdict })}
     const { verdict, details } = await runAndParseVerify();
     if (verdict === "pass") {
       supervisor.done = true;
+      supervisor.awaitingStrategist = false;
+      if (supervisor.ralphHandoffTimer) {
+        clearTimeout(supervisor.ralphHandoffTimer);
+        supervisor.ralphHandoffTimer = undefined;
+      }
       await run(writeFile(NodePath.join(worktree, FILES.NEXT_RALPH), interpolate(templates.doneFileContent, { timestamp: nowISO() })));
       await client.tui.showToast({
         body: { title: "Ralph: Done", message: "Verification passed. Loop complete.", variant: "success" }
@@ -25840,38 +25841,17 @@ ${interpolate(templates.continuePrompt, { attempt: String(attemptN), verdict })}
     await notifySupervisor(`worker/attempt-${supervisor.attempt}`, `Verification ${verdict}. Preparing next attempt.`, verdict === "fail" ? "warning" : "info", true, workerSessionId);
     supervisor.attempt += 1;
     await rolloverState(supervisor.attempt - 1, verdict, details);
-    await spawnRalphSession(supervisor.attempt);
-  };
-  const handleRalphSessionIdle = async (ralphSessionId) => {
-    if (supervisor.currentRalphSessionId !== ralphSessionId)
-      return;
-    if (supervisor.done)
-      return;
-    supervisor.currentRalphSessionId = undefined;
-    const st = sessionMap.get(ralphSessionId);
-    if (st && !st.reportedStatus) {
-      await notifySupervisor(`ralph/attempt-${st.attempt}`, "No explicit strategist status reported before idle.", "info", true, ralphSessionId);
-    }
-    if (!st?.workerSpawned) {
-      await client.tui.showToast({
-        body: {
-          title: "Ralph: no worker spawned",
-          message: `Ralph session for attempt ${st?.attempt ?? supervisor.attempt} ended without calling ralph_spawn_worker().`,
-          variant: "warning"
-        }
-      }).catch(() => {});
-      await notifySupervisor(`ralph/attempt-${st?.attempt ?? supervisor.attempt}`, "Strategist went idle without spawning a worker.", "warning", true, ralphSessionId);
-    }
+    await promptStrategistInMain(supervisor.attempt);
   };
   const handleMainIdle = async (sessionID) => {
     if (supervisor.done)
       return;
     if (supervisor.paused)
       return;
-    if (supervisor.currentRalphSessionId)
-      return;
     if (supervisor.currentWorkerSessionId)
       return;
+    if (supervisor.awaitingStrategist)
+      return;
     const cfg = await run(getConfig());
     if (!cfg.enabled)
       return;
@@ -25892,7 +25872,7 @@ ${interpolate(templates.continuePrompt, { attempt: String(attemptN), verdict })}
     }
     supervisor.attempt = 1;
     await notifySupervisor("supervisor", "Starting Ralph loop at attempt 1.", "info", true, sessionID);
-    await spawnRalphSession(1);
+    await promptStrategistInMain(1);
   };
   return {
     tool: {
@@ -25931,7 +25911,7 @@ ${interpolate(templates.continuePrompt, { attempt: String(attemptN), verdict })}
       output.system = output.system ?? [];
       const sessionID = input.sessionID ?? input.session_id ?? input.session?.id;
       const role = sessionMap.get(sessionID ?? "")?.role;
-      const base = role === "worker" || role === "subagent" ? templates.workerSystemPrompt : role === "ralph" ? templates.ralphSessionSystemPrompt : templates.systemPrompt;
+      const base = role === "worker" || role === "subagent" ? templates.workerSystemPrompt : templates.systemPrompt;
       const full = templates.systemPromptAppend ? `${base}
 ${templates.systemPromptAppend}` : base;
       output.system.push(full);
@@ -25973,8 +25953,6 @@ ${templates.systemPromptAppend}` : base;
         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();
@@ -25995,10 +25973,6 @@ ${templates.systemPromptAppend}` : base;
           await handleWorkerIdle(sessionID).catch((err) => {
             appLog("error", "handleWorkerIdle error", { error: String(err), sessionID });
           });
-        } else if (supervisor.currentRalphSessionId === sessionID) {
-          await handleRalphSessionIdle(sessionID).catch((err) => {
-            appLog("error", "handleRalphSessionIdle error", { error: String(err), sessionID });
-          });
         } else {
           await handleMainIdle(sessionID).catch((err) => {
             appLog("error", "handleMainIdle error", { error: String(err), sessionID });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ralph-rlm",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "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",