opencode-auto-loop 0.1.5 → 0.1.7

package/commands/auto-loop.md

@@ -4,20 +4,24 @@ description: "Start Auto Loop - auto-continues until task completion. Use: /auto
 
 # Auto Loop
 
-Parse `$ARGUMENTS` for the task description and an optional `--max <number>` flag.
+Parse `$ARGUMENTS` for the task description and optional flags:
 
 - If `$ARGUMENTS` contains `--max <number>`, extract that number as **maxIterations** and remove it from the task string.
 - Otherwise, use **maxIterations**: 25
+- If `$ARGUMENTS` contains `--ralph`, set **forceLoop** to `true` and remove it from the task string. Force mode ignores all completion signals and runs for the full maxIterations.
 
 Invoke the `auto-loop` tool with:
 
 - **task**: the extracted task description
 - **maxIterations**: the extracted or default value
+- **forceLoop**: `true` if `--ralph` was present, omit otherwise
 
 Examples:
 - `/auto-loop Build a REST API` → task="Build a REST API", maxIterations=25
 - `/auto-loop Build a REST API --max 50` → task="Build a REST API", maxIterations=50
 - `/auto-loop --max 10 Fix all lint errors` → task="Fix all lint errors", maxIterations=10
+- `/auto-loop --ralph Fix all lint errors` → task="Fix all lint errors", maxIterations=25, forceLoop=true
+- `/auto-loop --ralph --max 10 Fix all lint errors` → task="Fix all lint errors", maxIterations=10, forceLoop=true
 
 After the tool confirms the loop is active, **immediately begin working on the task**. Do not just acknowledge — start doing the work right away.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-auto-loop",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Auto-continue for OpenCode",
   "main": "src/index.ts",
   "type": "module",

package/skills/auto-loop/SKILL.md

@@ -21,7 +21,9 @@ Your previous work remains accessible through files, git history, and the state
 
 ## Starting the Loop
 
-**Always use the `auto-loop` tool** to start the loop. Do NOT create the state file manually. The tool handles state file creation, session tracking, and initialization.
+**Use the `auto-loop` tool ONCE to start the loop.** Do NOT create the state file manually. The tool handles state file creation, session tracking, and initialization.
+
+**CRITICAL: Do NOT call the `auto-loop` tool more than once per loop.** The plugin handles all subsequent iterations automatically via idle detection. Re-invoking the tool would be rejected to prevent accidental state resets. If you need to restart with different parameters, use `/cancel-auto-loop` first.
 
 After the tool confirms the loop is active, **immediately begin working on the task**. Do not just acknowledge — start doing the work.
 
@@ -78,6 +80,16 @@ The loop can only be stopped by:
 2. Max iterations reached
 3. User running `/cancel-auto-loop`
 
+## Force Mode (--ralph)
+
+When started with `--ralph`, the loop ignores ALL completion signals (`<promise>DONE</promise>`, `STATUS: COMPLETE`) and runs for the full iteration count. In force mode:
+- You do NOT need to output `STATUS:` lines or the DONE signal
+- The loop will continue for all iterations regardless
+- Focus on making steady progress each iteration
+- Still output `## Completed` and `## Next Steps` sections so the plugin can track progress
+
+Example: `/auto-loop --ralph --max 10 Continue the refactoring task`
+
 ## Checking Status
 
 Check current iteration and progress:

package/skills/auto-loop-help/SKILL.md

@@ -19,6 +19,15 @@ Example:
 
 The AI will work on your task and automatically continue until completion.
 
+### `/auto-loop <task> --ralph`
+Force mode: ignore all completion signals and run for the full iteration count. Useful when you got interrupted and want to resume, or when you want the AI to keep iterating without stopping early.
+
+Examples:
+```
+/auto-loop --ralph Continue the refactoring
+/auto-loop --ralph --max 10 Fix all lint errors
+```
+
 ### `/cancel-auto-loop`
 Cancel an active Auto Loop before it completes.
 
@@ -35,7 +44,7 @@ Show plugin help and available commands.
 1. **Start**: `/auto-loop` creates a state file at `.opencode/auto-loop.local.md`
 2. **Loop**: When the AI goes idle, the plugin checks if `<promise>DONE</promise>` was output
 3. **Continue**: If not found, it injects "Continue from where you left off"
-4. **Stop**: Loop continues until DONE is found or max iterations (100) reached
+4. **Stop**: Loop continues until DONE is found or max iterations (default: 25) reached
 5. **Cleanup**: State file is deleted when complete
 6. **Compaction**: Loop context survives session compaction — task and iteration info is preserved
 

package/skills/cancel-auto-loop/SKILL.md

@@ -9,33 +9,19 @@ Stop an active Auto Loop before completion.
 
 ## How to Use
 
-When you invoke this skill:
+When you need to cancel the loop, invoke the `cancel-auto-loop` tool. The tool will:
 
-1. First, check if a loop is active:
+1. Check if a loop is currently active
+2. Report how many iterations were completed
+3. Clean up the state file
 
-```bash
-test -f .opencode/auto-loop.local.md && echo "Loop is active" || echo "No active loop"
-```
-
-2. If active, read the current iteration count:
-
-```bash
-grep '^iteration:' .opencode/auto-loop.local.md
-```
-
-3. Delete the state file to stop the loop:
-
-```bash
-rm -f .opencode/auto-loop.local.md
-```
-
-4. Inform the user of the cancellation and which iteration was reached.
+**That's it.** Just call the `cancel-auto-loop` tool. Do NOT manually delete the state file.
 
 ## When to Use
 
 Use this command when:
 - The task requirements have changed
-- You want to restart with different parameters
+- You want to restart with different parameters (cancel first, then `/auto-loop` again)
 - The loop appears stuck and you want manual control
 - You need to work on something else
 

package/src/index.ts

@@ -16,6 +16,7 @@ interface LoopState {
   iteration: number;
   maxIterations: number;
   debounceMs: number;
+  forceLoop?: boolean;
   sessionId?: string;
   prompt?: string;
   completed?: string;
@@ -106,7 +107,7 @@ function getStateFile(directory: string): string {
 
 // Parse markdown frontmatter state
 function parseState(content: string): LoopState {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return { active: false, iteration: 0, maxIterations: DEFAULT_MAX_ITERATIONS, debounceMs: DEFAULT_DEBOUNCE_MS };
 
   const frontmatter = match[1];
@@ -117,13 +118,23 @@ function parseState(content: string): LoopState {
     debounceMs: DEFAULT_DEBOUNCE_MS,
   };
 
-  for (const line of frontmatter.split("\n")) {
+  for (const line of frontmatter.split(/\r?\n/)) {
     const [key, ...valueParts] = line.split(":");
     const value = valueParts.join(":").trim();
     if (key === "active") state.active = value === "true";
-    if (key === "iteration") state.iteration = parseInt(value) || 0;
-    if (key === "maxIterations") state.maxIterations = parseInt(value) || DEFAULT_MAX_ITERATIONS;
-    if (key === "debounceMs") state.debounceMs = parseInt(value) || DEFAULT_DEBOUNCE_MS;
+    if (key === "iteration") {
+      const parsed = parseInt(value, 10);
+      state.iteration = Number.isNaN(parsed) ? 0 : Math.max(0, parsed);
+    }
+    if (key === "maxIterations") {
+      const parsed = parseInt(value, 10);
+      state.maxIterations = (Number.isFinite(parsed) && parsed > 0) ? parsed : DEFAULT_MAX_ITERATIONS;
+    }
+    if (key === "debounceMs") {
+      const parsed = parseInt(value, 10);
+      state.debounceMs = (Number.isFinite(parsed) && parsed >= 0) ? parsed : DEFAULT_DEBOUNCE_MS;
+    }
+    if (key === "forceLoop") state.forceLoop = value === "true";
     if (key === "sessionId") state.sessionId = value || undefined;
   }
 
@@ -159,6 +170,7 @@ function serializeState(state: LoopState): string {
     `maxIterations: ${state.maxIterations}`,
     `debounceMs: ${state.debounceMs}`,
   ];
+  if (state.forceLoop) lines.push(`forceLoop: ${state.forceLoop}`);
   if (state.sessionId) lines.push(`sessionId: ${state.sessionId}`);
   lines.push("---");
   if (state.prompt) lines.push("", state.prompt);
@@ -244,9 +256,12 @@ async function getLastAssistantText(
   }
 }
 
-// Check completion by looking for <promise>DONE</promise> in last assistant text
+// Check completion by looking for <promise>DONE</promise> OR STATUS: COMPLETE
+// in the last assistant text. Either signal indicates the AI believes the task
+// is finished. The validateCompletion() function further validates legitimacy.
 function checkCompletion(text: string): boolean {
-  return COMPLETION_TAG.test(stripCodeFences(text));
+  const cleaned = stripCodeFences(text);
+  return COMPLETION_TAG.test(cleaned) || STATUS_COMPLETE_TAG.test(cleaned);
 }
 
 // Extract the STATUS signal presence from text.
@@ -412,16 +427,26 @@ function buildProgressSection(state: LoopState): string {
 // Build the loop context reminder for post-compaction injection
 function buildLoopContextReminder(state: LoopState): string {
   const progress = buildProgressSection(state);
-  return `[AUTO LOOP ACTIVE — Iteration ${state.iteration}/${state.maxIterations}]
-
-Original task: ${state.prompt || "(no task specified)"}
-${progress}
-IMPORTANT RULES:
+  const forceLabel = state.forceLoop ? " [FORCE MODE]" : "";
+  const rules = state.forceLoop
+    ? `IMPORTANT RULES:
+- Do NOT call the auto-loop tool — the plugin handles continuation automatically
+- Before going idle, output ## Completed and ## Next Steps sections
+- FORCE MODE is active — the loop will continue for all ${state.maxIterations} iterations regardless of completion signals
+- Focus on making steady progress each iteration`
+    : `IMPORTANT RULES:
+- Do NOT call the auto-loop tool — the plugin handles continuation automatically
 - Before going idle, output ## Completed and ## Next Steps sections
 - You MUST include a STATUS line: either \`STATUS: IN_PROGRESS\` or \`STATUS: COMPLETE\` on its own line
 - Do NOT output <promise>DONE</promise> if there are ANY unchecked items (\`- [ ]\`) in your Next Steps — the plugin WILL reject it
 - Only output \`STATUS: COMPLETE\` and the DONE signal when ALL steps are truly finished and Next Steps is empty
 - Do NOT output false completion promises. If blocked, output \`STATUS: IN_PROGRESS\` and explain the blocker.`;
+
+  return `[AUTO LOOP${forceLabel} ACTIVE — Iteration ${state.iteration}/${state.maxIterations}]
+
+Original task: ${state.prompt || "(no task specified)"}
+${progress}
+${rules}`;
 }
 
 // Check if session is currently busy (not idle)
@@ -481,11 +506,10 @@ export const AutoLoopPlugin: Plugin = async (ctx) => {
 
   // Debounce tracking for idle events
   let lastContinuation = 0;
-  // Guard: prevent sending while a continuation is already in-flight.
-  // Set to true when we send promptAsync, cleared when we receive a
-  // session.idle or session.status(idle) event — NOT in the finally block,
-  // which fires too early (~50ms after the 204, while AI is still busy).
-  let continuationInFlight = false;
+  // Reentrant guard: prevent concurrent idle event processing.
+  // Two idle events can interleave at await points, causing duplicate
+  // state reads/writes. This ensures only one handler runs at a time.
+  let handlingIdle = false;
 
   return {
     tool: {
@@ -504,33 +528,68 @@ export const AutoLoopPlugin: Plugin = async (ctx) => {
             .number()
             .optional()
             .describe("Debounce delay between iterations in ms (default: 2000)"),
+          forceLoop: tool.schema
+            .boolean()
+            .optional()
+            .describe("Force mode (--ralph): ignore completion signals and run for all iterations"),
         },
-        async execute({ task, maxIterations = DEFAULT_MAX_ITERATIONS, debounceMs = DEFAULT_DEBOUNCE_MS }, context) {
+        async execute({ task, maxIterations = DEFAULT_MAX_ITERATIONS, debounceMs = DEFAULT_DEBOUNCE_MS, forceLoop = false }, context) {
           if (context.abort.aborted) return "Auto Loop start was cancelled.";
 
+          // Coerce parameters to correct types (AI may pass strings)
+          const parsedMax = parseInt(String(maxIterations), 10);
+          const safeMaxIterations = (typeof maxIterations === "number" && maxIterations > 0)
+            ? maxIterations
+            : (Number.isFinite(parsedMax) && parsedMax > 0 ? parsedMax : DEFAULT_MAX_ITERATIONS);
+          const parsedDebounce = parseInt(String(debounceMs), 10);
+          const safeDebounceMs = (typeof debounceMs === "number" && debounceMs >= 0)
+            ? debounceMs
+            : (Number.isFinite(parsedDebounce) && parsedDebounce >= 0 ? parsedDebounce : DEFAULT_DEBOUNCE_MS);
+
+          // Guard: if a loop is already active for this session, do NOT reset state.
+          // This prevents the AI from accidentally re-invoking the tool each iteration
+          // (which would reset the iteration counter back to 0 every time).
+          const existingState = await readState(directory);
+          if (existingState.active && existingState.sessionId === context.sessionID) {
+            log("warn", `Tool re-invoked while loop already active (iteration ${existingState.iteration}/${existingState.maxIterations}). Ignoring to prevent state reset.`);
+            return `Auto Loop is ALREADY ACTIVE (iteration ${existingState.iteration}/${existingState.maxIterations}). Do NOT call the auto-loop tool again — the plugin handles continuation automatically. Just keep working on the task. Use /cancel-auto-loop first if you need to restart with different parameters.`;
+          }
+          if (existingState.active && existingState.sessionId && existingState.sessionId !== context.sessionID) {
+            log("warn", `Starting new loop in session ${context.sessionID}, overwriting active loop from session ${existingState.sessionId} (was at iteration ${existingState.iteration}/${existingState.maxIterations})`);
+            toast(`Auto Loop: replacing active loop from another session`, "warning");
+          }
+
           const state: LoopState = {
             active: true,
             iteration: 0,
-            maxIterations,
-            debounceMs,
+            maxIterations: safeMaxIterations,
+            debounceMs: safeDebounceMs,
+            forceLoop: forceLoop ? true : undefined,
             sessionId: context.sessionID,
             prompt: task,
           };
           await writeState(directory, state, log);
           // Reset guards so the first idle event is not blocked
-          continuationInFlight = false;
+          handlingIdle = false;
           lastContinuation = 0;
 
-          log("info", `Loop started for session ${context.sessionID}`);
-          toast(`Auto Loop started (max ${maxIterations} iterations)`, "success");
+          const modeLabel = forceLoop ? " [FORCE MODE]" : "";
+          log("info", `Loop started${modeLabel} for session ${context.sessionID}`);
+          toast(`Auto Loop started${modeLabel} (max ${safeMaxIterations} iterations)`, "success");
+
+          const forceNote = forceLoop
+            ? `\n\n**FORCE MODE (--ralph):** Completion signals are IGNORED. The loop will run for all ${safeMaxIterations} iterations regardless. Focus on making steady progress each iteration — you do NOT need to output STATUS or DONE signals.`
+            : "";
 
-          return `Auto Loop started (max ${maxIterations} iterations).
+          return `Auto Loop started (max ${safeMaxIterations} iterations).${forceNote}
 
 Task: ${task}
 
-**Begin working on the task now.** The loop will auto-continue until you signal completion.
+**Begin working on the task now.** The loop will auto-continue until ${forceLoop ? `all ${safeMaxIterations} iterations are used` : "you signal completion"}.
 
-Before going idle each iteration, output structured progress AND a status line:
+**CRITICAL: Do NOT call the auto-loop tool again.** The plugin handles auto-continuation automatically via idle detection. Re-invoking the tool would reset your progress. Just work on the task — the plugin will prompt you to continue when you go idle.
+
+Before going idle each iteration, output structured progress${forceLoop ? "" : " AND a status line"}:
 
 \`\`\`
 ## Completed
@@ -538,10 +597,9 @@ Before going idle each iteration, output structured progress AND a status line:
 
 ## Next Steps
 - [ ] What remains (in priority order)
-
-STATUS: IN_PROGRESS
+${forceLoop ? "" : "\nSTATUS: IN_PROGRESS"}
 \`\`\`
-
+${forceLoop ? "" : `
 ## Completion Rules — READ CAREFULLY
 
 1. **If your Next Steps list has ANY unchecked items (\`- [ ]\`), you MUST NOT output the DONE signal.** The plugin will reject it.
@@ -550,7 +608,7 @@ STATUS: IN_PROGRESS
    - \`STATUS: COMPLETE\` on its own line
    - The promise-DONE XML tag on its own line
 4. If you are blocked or stuck, output \`STATUS: IN_PROGRESS\` and explain the blocker. Do NOT output a false DONE.
-
+`}
 Use /cancel-auto-loop to stop early.`;
         },
       }),
@@ -566,7 +624,8 @@ Use /cancel-auto-loop to stop early.`;
           }
           const iterations = state.iteration;
           await clearState(directory, log);
-          continuationInFlight = false;
+          handlingIdle = false;
+          lastContinuation = 0;
 
           log("info", `Loop cancelled after ${iterations} iteration(s)`);
           toast(`Auto Loop cancelled after ${iterations} iteration(s)`, "warning");
@@ -585,6 +644,8 @@ Use /cancel-auto-loop to stop early.`;
 
 - \`/auto-loop <task>\` - Start an auto-continuation loop (default: 25 iterations)
 - \`/auto-loop <task> --max <n>\` - Start with a custom iteration limit
+- \`/auto-loop <task> --ralph\` - Force mode: ignore completion signals, run all iterations
+- \`/auto-loop <task> --ralph --max <n>\` - Force mode with custom limit
 - \`/cancel-auto-loop\` - Stop an active loop
 - \`/auto-loop-help\` - Show this help
 
@@ -592,6 +653,8 @@ Use /cancel-auto-loop to stop early.`;
 
 - \`/auto-loop Build a REST API\` — runs up to 25 iterations
 - \`/auto-loop Fix all lint errors --max 10\` — runs up to 10 iterations
+- \`/auto-loop --ralph Continue refactoring\` — force runs all 25 iterations, ignores DONE signals
+- \`/auto-loop --ralph --max 50 Big migration\` — force runs all 50 iterations
 
 ## How It Works
 
@@ -600,6 +663,13 @@ Use /cancel-auto-loop to stop early.`;
 3. Plugin auto-continues if not complete
 4. Loop stops when AI outputs: <promise>DONE</promise>
 
+## Force Mode (--ralph)
+
+When \`--ralph\` is used, the loop ignores ALL completion signals and runs for the full iteration count. Useful when:
+- You got interrupted and want to continue no matter what
+- You want the AI to keep iterating and improving
+- You don't want the AI to stop early
+
 ## State File
 
 Located at: .opencode/auto-loop.local.md`;
@@ -613,107 +683,158 @@ Located at: .opencode/auto-loop.local.md`;
       if (event.type === "session.idle") {
         const sessionId = event.properties.sessionID;
 
-        // Session confirmed idle — safe to clear in-flight guard
-        continuationInFlight = false;
-
-        const state = await readState(directory);
-
-        if (!state.active) return;
-        if (!sessionId) return;
-        if (state.sessionId && state.sessionId !== sessionId) return;
+        // Reentrant guard: if we're already processing an idle event,
+        // skip this one. Two idle events can interleave at await points,
+        // causing duplicate state reads/writes and double continuations.
+        if (handlingIdle) {
+          log("debug", "Idle handler already running, skipping duplicate event");
+          return;
+        }
+        handlingIdle = true;
 
-        const now = Date.now();
-        if (now - lastContinuation < state.debounceMs) return;
+        try {
+          const state = await readState(directory);
 
-        // Double-check the session is truly idle before sending
-        if (await isSessionBusy(client, sessionId, log)) return;
+          if (!state.active) return;
+          if (!sessionId) return;
+          if (state.sessionId && state.sessionId !== sessionId) return;
+
+          const now = Date.now();
+          if (now - lastContinuation < state.debounceMs) return;
+
+          // Double-check the session is truly idle before sending
+          if (await isSessionBusy(client, sessionId, log)) return;
+
+          // Fetch last assistant message (used for completion check + progress extraction)
+          const lastText = await getLastAssistantText(client, sessionId, directory, log);
+
+          // Skip completion check on iteration 0 (first idle after loop start)
+          // to avoid false positives from the tool's initial response text.
+          // Also skip entirely when forceLoop is true — force mode ignores
+          // all completion signals and runs until max iterations.
+          if (!state.forceLoop && state.iteration > 0 && lastText && checkCompletion(lastText)) {
+            // Validate the DONE signal — reject if there are unchecked steps
+            // or if the STATUS signal contradicts completion
+            const validation = validateCompletion(lastText);
+            if (validation.valid) {
+              await clearState(directory, log);
+              log("info", `Loop completed at iteration ${state.iteration}`);
+              toast(`Auto Loop completed after ${state.iteration} iteration(s)`, "success");
+              return;
+            } else {
+              log("warn", `Rejected premature DONE signal: ${validation.reason}`);
+              toast(`Auto Loop: DONE rejected — ${validation.reason}`, "warning");
+              // Fall through to send another continuation prompt
+            }
+          }
 
-        // Fetch last assistant message (used for completion check + progress extraction)
-        const lastText = await getLastAssistantText(client, sessionId, directory, log);
+          // Heuristic: if the AI has no remaining work, stop the loop even
+          // without an explicit DONE/STATUS signal. This catches cases where
+          // the AI says "all done" naturally without the structured tag.
+          // Conditions: not force mode, at least 1 iteration done, the last
+          // response has no unchecked steps, AND the persisted state also has
+          // no unchecked next steps.
+          if (!state.forceLoop && state.iteration > 0 && lastText) {
+            const responseHasWork = hasIncompleteSteps(lastText);
+            const stateHasWork = state.nextSteps
+              ? /^\s*-\s*\[ \]/m.test(state.nextSteps)
+              : false;
+            const { hasInProgress } = getStatusSignals(lastText);
+
+            // No unchecked steps anywhere AND no explicit IN_PROGRESS signal
+            if (!responseHasWork && !stateHasWork && !hasInProgress) {
+              // Extra guard: only trigger if the response doesn't introduce
+              // new next-steps content (even without checkboxes)
+              const newSteps = extractNextSteps(lastText);
+              const hasNewWork = newSteps && newSteps.trim().length > 0;
+              if (!hasNewWork) {
+                await clearState(directory, log);
+                log("info", `Loop completed at iteration ${state.iteration} (no remaining work detected)`);
+                toast(`Auto Loop completed after ${state.iteration} iteration(s)`, "success");
+                return;
+              }
+            }
+          }
 
-        // Skip completion check on iteration 0 (first idle after loop start)
-        // to avoid false positives from the tool's initial response text
-        if (state.iteration > 0 && lastText && checkCompletion(lastText)) {
-          // Validate the DONE signal — reject if there are unchecked steps
-          // or if the STATUS signal contradicts completion
-          const validation = validateCompletion(lastText);
-          if (validation.valid) {
+          if (state.iteration >= state.maxIterations) {
             await clearState(directory, log);
-            log("info", `Loop completed at iteration ${state.iteration}`);
-            toast(`Auto Loop completed after ${state.iteration} iteration(s)`, "success");
+            log("warn", `Loop hit max iterations (${state.maxIterations})`);
+            toast(`Auto Loop stopped — max iterations (${state.maxIterations}) reached`, "warning");
             return;
-          } else {
-            log("warn", `Rejected premature DONE signal: ${validation.reason}`);
-            toast(`Auto Loop: DONE rejected — ${validation.reason}`, "warning");
-            // Fall through to send another continuation prompt
           }
-        }
-
-        if (state.iteration >= state.maxIterations) {
-          await clearState(directory, log);
-          log("warn", `Loop hit max iterations (${state.maxIterations})`);
-          toast(`Auto Loop stopped — max iterations (${state.maxIterations}) reached`, "warning");
-          return;
-        }
 
-        // Extract progress from last message and merge with existing state
-        const newNextSteps = lastText ? extractNextSteps(lastText) : undefined;
-        const newCompleted = lastText ? extractCompleted(lastText) : undefined;
+          // Extract progress from last message and merge with existing state
+          const newNextSteps = lastText ? extractNextSteps(lastText) : undefined;
+          const newCompleted = lastText ? extractCompleted(lastText) : undefined;
 
-        const newState: LoopState = {
-          ...state,
-          iteration: state.iteration + 1,
-          sessionId,
-          nextSteps: newNextSteps || state.nextSteps,
-          completed: mergeCompleted(state.completed, newCompleted),
-        };
-        await writeState(directory, newState, log);
-        lastContinuation = Date.now();
-
-        // Build continuation prompt with progress context
-        const progressSection = buildProgressSection(newState);
+          const newState: LoopState = {
+            ...state,
+            iteration: state.iteration + 1,
+            sessionId,
+            nextSteps: newNextSteps || state.nextSteps,
+            completed: mergeCompleted(state.completed, newCompleted),
+          };
+          await writeState(directory, newState, log);
+          lastContinuation = Date.now();
+
+          // Verify the state write persisted correctly
+          const verifyState = await readState(directory);
+          if (verifyState.iteration !== newState.iteration) {
+            log("error", `State file write verification FAILED: expected iteration ${newState.iteration}, read back ${verifyState.iteration}`);
+            toast(`Auto Loop: state write failed! Check .opencode/ permissions.`, "error");
+            return;
+          }
 
-        const continuationPrompt = `[AUTO LOOP — ITERATION ${newState.iteration}/${newState.maxIterations}]
+          // Build continuation prompt with progress context
+          const progressSection = buildProgressSection(newState);
 
-Continue working on the task. Do NOT repeat work that is already done.
-${progressSection}
-IMPORTANT:
+          const forceLabel = state.forceLoop ? " [FORCE MODE]" : "";
+          const importantRules = state.forceLoop
+            ? `IMPORTANT:
+- Do NOT call the auto-loop tool — the plugin handles continuation automatically
+- Pick up from the next incomplete step below
+- Before going idle, list your progress using ## Completed and ## Next Steps sections
+- FORCE MODE is active — the loop will continue for all ${newState.maxIterations} iterations regardless of completion signals
+- Focus on making steady progress each iteration`
+            : `IMPORTANT:
+- Do NOT call the auto-loop tool — the plugin handles continuation automatically
 - Pick up from the next incomplete step below
 - Before going idle, list your progress using ## Completed and ## Next Steps sections
 - You MUST include a STATUS line: either \`STATUS: IN_PROGRESS\` or \`STATUS: COMPLETE\` on its own line
 - Do NOT output <promise>DONE</promise> if there are ANY unchecked items (\`- [ ]\`) in your Next Steps — the plugin WILL reject it
 - Only output \`STATUS: COMPLETE\` and the DONE signal when ALL steps are truly finished and Next Steps is empty
-- Do not stop until the task is truly done
+- Do not stop until the task is truly done`;
+
+          const continuationPrompt = `[AUTO LOOP${forceLabel} — ITERATION ${newState.iteration}/${newState.maxIterations}]
+
+Continue working on the task. Do NOT repeat work that is already done.
+Do NOT call the auto-loop tool again — the plugin handles auto-continuation.
+${progressSection}
+${importantRules}
 
 Original task:
 ${state.prompt || "(no task specified)"}`;
 
-        try {
-          // Use promptAsync (fire-and-forget) so the event handler returns
-          // immediately. This allows the next session.idle event to fire
-          // naturally when the AI finishes, enabling the loop to continue.
-          // The synchronous prompt() blocks until the AI response completes,
-          // which prevents subsequent idle events from being processed.
-          continuationInFlight = true;
-          await client.session.promptAsync({
-            path: { id: sessionId },
-            body: {
-              parts: [{ type: "text", text: continuationPrompt }],
-            },
-          });
-          log("info", `Sent continuation ${newState.iteration}/${newState.maxIterations}`);
-          toast(`Auto Loop: iteration ${newState.iteration}/${newState.maxIterations}`);
-        } catch (err) {
-          // On failure, clear the guard so the next idle event can retry
-          continuationInFlight = false;
-          log("error", `Failed to send continuation prompt: ${err}`);
-        }
-      }
-
-      // --- session.status: clear in-flight guard when session returns to idle ---
-      if (event.type === "session.status") {
-        if (event.properties.status?.type === "idle") {
-          continuationInFlight = false;
+          try {
+            // Use promptAsync (fire-and-forget) so the event handler returns
+            // immediately. This allows the next session.idle event to fire
+            // naturally when the AI finishes, enabling the loop to continue.
+            // The synchronous prompt() blocks until the AI response completes,
+            // which prevents subsequent idle events from being processed.
+            await client.session.promptAsync({
+              path: { id: sessionId },
+              body: {
+                parts: [{ type: "text", text: continuationPrompt }],
+              },
+            });
+            log("info", `Sent continuation ${newState.iteration}/${newState.maxIterations}`);
+            toast(`Auto Loop: iteration ${newState.iteration}/${newState.maxIterations}`);
+          } catch (err) {
+            log("error", `Failed to send continuation prompt: ${err}`);
+            toast(`Auto Loop: failed to send continuation — ${err}`, "error");
+          }
+        } finally {
+          handlingIdle = false;
         }
       }
 
@@ -755,7 +876,8 @@ ${state.prompt || "(no task specified)"}`;
         ) {
           log("warn", `Session error detected, pausing loop at iteration ${state.iteration}`);
           toast("Auto Loop paused — session error", "error");
-          continuationInFlight = false;
+          handlingIdle = false;
+          lastContinuation = 0;
           // Mark inactive but keep state so user can inspect/resume
           await writeState(directory, { ...state, active: false }, log);
         }
@@ -770,7 +892,8 @@ ${state.prompt || "(no task specified)"}`;
         if (state.sessionId && deletedSessionId && state.sessionId !== deletedSessionId) return;
 
         await clearState(directory, log);
-        continuationInFlight = false;
+        handlingIdle = false;
+        lastContinuation = 0;
         log("info", "Session deleted, cleaning up loop state");
       }
     },