opencode-auto-loop 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tim Lang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# opencode-auto-loop
+
+Auto Loop plugin for [opencode](https://opencode.ai) — auto-continues until task completion.
+
+## Installation
+
+Add to your `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-auto-loop"]
+}
+```
+
+Restart opencode. That's it!
+
+On first run, the plugin will automatically install skills and commands to your `~/.config/opencode/` directory.
+
+## Usage
+
+### Start a loop
+
+```
+/auto-loop "Build a REST API with authentication"
+```
+
+The AI will work on your task and automatically continue until completion.
+
+### Cancel a loop
+
+```
+/cancel-auto-loop
+```
+
+### Get help
+
+```
+/auto-loop-help
+```
+
+## How it works
+
+1. `/auto-loop` creates a state file at `.opencode/auto-loop.local.md`
+2. When the AI goes idle, the plugin checks if `<promise>DONE</promise>` was output
+3. If not found, it extracts progress (## Completed / ## Next Steps) and injects a continuation prompt
+4. Loop continues until DONE is found or max iterations (100) reached
+5. State file is deleted when complete
+6. Loop context survives session compaction
+
+### Progress Tracking
+
+The plugin extracts `## Completed` and `## Next Steps` sections from each iteration and persists them in the state file. On continuation, these are included in the prompt so the AI knows exactly where to pick up.
+
+### Completion Promise
+
+When the AI finishes a task, it outputs:
+
+```
+<promise>DONE</promise>
+```
+
+The AI should ONLY output this when the task is COMPLETELY and VERIFIABLY finished.
+
+## State File
+
+The loop state is stored in your project directory:
+
+```
+.opencode/auto-loop.local.md
+```
+
+Format (markdown with YAML frontmatter):
+
+```markdown
+---
+active: true
+iteration: 3
+maxIterations: 100
+sessionId: ses_abc123
+---
+
+Your original task prompt
+
+## Completed
+- [x] Set up project structure
+- [x] Created database schema
+
+## Next Steps
+- [ ] Add JWT authentication middleware
+- [ ] Create registration endpoint
+```
+
+Add `.opencode/auto-loop.local.md` to your `.gitignore`.
+
+## Features
+
+- **Plug-and-play**: Just add to config and restart
+- **Auto-setup**: Skills and commands are automatically installed on first run
+- **Progress tracking**: Extracts and persists TODOs across iterations
+- **Compaction-safe**: Loop context survives session compaction
+- **Project-relative**: State file in `.opencode/`, not global
+- **Completion detection**: Scans session messages for DONE promise (ignores code fences)
+- **Toast notifications**: Visual feedback on loop start, iteration, completion
+- **Error handling**: Pauses on session errors, cleans up on session deletion
+- **Debounced**: Prevents duplicate continuations from rapid idle events
+- **Commands**: `/auto-loop`, `/cancel-auto-loop`, and `/auto-loop-help`
+
+## Architecture
+
+```
+opencode-auto-loop/
+├── src/
+│   └── index.ts          # Main plugin with event hooks and tools
+├── skills/
+│   ├── auto-loop/        # Progressive context for starting loops
+│   ├── cancel-auto-loop/      # Context for cancellation
+│   └── help/             # Plugin documentation
+├── commands/
+│   ├── auto-loop.md      # Slash command for starting
+│   ├── cancel-auto-loop.md    # Slash command for cancelling
+│   └── help.md           # Slash command for help
+├── tsconfig.json
+└── package.json
+```
+
+## License
+
+MIT

package/commands/auto-loop-help.md

@@ -0,0 +1,36 @@
+---
+description: Show Auto Loop plugin help and available commands
+---
+
+# Auto Loop Help
+
+## Available Commands
+
+- `/auto-loop <task>` - Start an auto-continuation loop for the given task
+- `/cancel-auto-loop` - Stop an active Auto Loop
+- `/auto-loop-help` - Show this help
+
+## Quick Start
+
+```
+/auto-loop Build a REST API with user authentication
+```
+
+The AI will work on your task and automatically continue until it outputs `<promise>DONE</promise>` to signal completion.
+
+## How It Works
+
+1. Creates state file at `.opencode/auto-loop.local.md`
+2. Works on task until idle
+3. If no `<promise>DONE</promise>` found, auto-continues
+4. Repeats until complete or max iterations (100) reached
+5. Survives context compaction — loop state is injected into the summary
+
+## Cancellation
+
+To stop early:
+```
+/cancel-auto-loop
+```
+
+For more details, the AI can use the `auto-loop-help` tool.

package/commands/auto-loop.md

@@ -0,0 +1,55 @@
+---
+description: Start Auto Loop - auto-continues until task completion
+---
+
+# Auto Loop
+
+Start an iterative development loop that automatically continues until the task is complete.
+
+## Setup
+
+Create the state file in the project directory:
+
+```bash
+mkdir -p .opencode && cat > .opencode/auto-loop.local.md << 'EOF'
+---
+active: true
+iteration: 0
+maxIterations: 100
+---
+
+$ARGUMENTS
+EOF
+```
+
+## Task
+
+Now begin working on the task: **$ARGUMENTS**
+
+## Progress Tracking
+
+Before going idle, you MUST output structured progress so the plugin knows where you left off:
+
+```markdown
+## Completed
+- [x] What you finished this iteration
+
+## Next Steps
+- [ ] What needs to be done next (in priority order)
+```
+
+The plugin extracts these into the state file for the next iteration's continuation prompt.
+
+## Completion
+
+When the task is FULLY completed, signal completion by outputting:
+
+```
+<promise>DONE</promise>
+```
+
+**IMPORTANT:** ONLY output this when the task is COMPLETELY and VERIFIABLY finished. Do NOT output false promises to escape the loop.
+
+## Cancellation
+
+Use `/cancel-auto-loop` to stop early.

package/commands/cancel-auto-loop.md

@@ -0,0 +1,23 @@
+---
+description: Cancel active Auto Loop
+---
+
+# Cancel Loop
+
+Cancel the active Auto Loop.
+
+## Steps
+
+1. Check if a loop is active and get the iteration count:
+
+```bash
+if [ -f .opencode/auto-loop.local.md ]; then
+  grep '^iteration:' .opencode/auto-loop.local.md
+  rm -f .opencode/auto-loop.local.md
+  echo "Auto Loop cancelled."
+else
+  echo "No active Auto Loop to cancel."
+fi
+```
+
+2. Report the result to the user.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "opencode-auto-loop",
+  "version": "0.1.0",
+  "description": "Auto-continue for OpenCode",
+  "main": "src/index.ts",
+  "type": "module",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "auto-continue",
+    "auto-loop",
+    "iteration-loop"
+  ],
+  "author": "Tim Lang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/timmyjl12/opencode-auto-loop"
+  },
+  "bugs": {
+    "url": "https://github.com/timmyjl12/opencode-auto-loop/issues"
+  },
+  "homepage": "https://github.com/timmyjl12/opencode-auto-loop#readme",
+  "files": [
+    "src/",
+    "commands/",
+    "skills/"
+  ],
+  "dependencies": {
+    "@opencode-ai/plugin": "^0.15.31"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0"
+  }
+}

package/skills/auto-loop/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: auto-loop
+description: Start Auto Loop - auto-continues until task completion
+---
+
+# Auto Loop
+
+Start an iterative development loop that automatically continues until the task is complete.
+
+## How It Works
+
+The Auto Loop creates a continuous feedback cycle for completing complex tasks:
+
+1. You work on the task until you go idle
+2. The plugin detects the idle state and checks for completion
+3. If not complete, it extracts your progress and prompts you to continue
+4. This repeats until you output the completion promise or max iterations reached
+
+Your previous work remains accessible through files, git history, and the state file's progress sections.
+
+## Starting the Loop
+
+When you invoke this skill, create the state file in the project directory:
+
+```bash
+mkdir -p .opencode && cat > .opencode/auto-loop.local.md << 'EOF'
+---
+active: true
+iteration: 0
+maxIterations: 100
+---
+
+[The user's task prompt goes here]
+EOF
+```
+
+Then inform the user and begin working on the task.
+
+## Progress Tracking - CRITICAL
+
+**Before going idle at the end of each work session, you MUST output structured progress sections.** The plugin parses these to persist your TODOs across iterations so you know exactly where to pick up.
+
+Use this format in your final message of each iteration:
+
+```markdown
+## Completed
+- [x] Set up project structure
+- [x] Created database schema
+- [x] Implemented user model
+
+## Next Steps
+- [ ] Add JWT authentication middleware
+- [ ] Create registration endpoint
+- [ ] Write integration tests
+```
+
+**Rules:**
+- Always use checkbox format (`- [x]` for done, `- [ ]` for remaining)
+- Be specific — each item should be a concrete, actionable step
+- Only list truly completed items under ## Completed
+- Order ## Next Steps by priority — the continuation will tell you to start from the top
+- The plugin extracts these sections and writes them into `auto-loop.local.md` for the next iteration
+
+## Completion Promise - CRITICAL RULES
+
+When you have FULLY completed the task, signal completion by outputting:
+
+```
+<promise>DONE</promise>
+```
+
+**IMPORTANT CONSTRAINTS:**
+
+- ONLY output `<promise>DONE</promise>` when the task is COMPLETELY and VERIFIABLY finished
+- The statement MUST be completely and unequivocally TRUE
+- Do NOT output false promises to escape the loop, even if you think you're stuck
+- Do NOT lie even if you think you should exit for other reasons
+- If you're blocked, explain the blocker and request help instead of falsely completing
+
+The loop can only be stopped by:
+1. Truthful completion promise
+2. Max iterations reached
+3. User running `/cancel-auto-loop`
+
+## Checking Status
+
+Check current iteration and progress:
+```bash
+cat .opencode/auto-loop.local.md
+```
+
+## State File Format
+
+The state file at `.opencode/auto-loop.local.md` uses YAML frontmatter with progress sections:
+
+```markdown
+---
+active: true
+iteration: 3
+maxIterations: 100
+sessionId: ses_abc123
+---
+
+Build a REST API with authentication
+
+## Completed
+- [x] Set up project structure
+- [x] Created database schema
+
+## Next Steps
+- [ ] Add JWT authentication middleware
+- [ ] Create registration endpoint
+- [ ] Write integration tests
+```
+
+Add `.opencode/auto-loop.local.md` to your `.gitignore`.

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

@@ -0,0 +1,76 @@
+---
+name: auto-loop-help
+description: Explain Auto Loop plugin and available commands
+---
+
+# Auto Loop Help
+
+The Auto Loop plugin provides auto-continuation for complex tasks in opencode.
+
+## Available Commands
+
+### `/auto-loop <task>`
+Start an iterative development loop that automatically continues until the task is complete.
+
+Example:
+```
+/auto-loop Build a REST API with authentication
+```
+
+The AI will work on your task and automatically continue until completion.
+
+### `/cancel-auto-loop`
+Cancel an active Auto Loop before it completes.
+
+Example:
+```
+/cancel-auto-loop
+```
+
+### `/auto-loop-help`
+Show plugin help and available commands.
+
+## How It Works
+
+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
+5. **Cleanup**: State file is deleted when complete
+6. **Compaction**: Loop context survives session compaction — task and iteration info is preserved
+
+## Completion Signal
+
+When the task is fully complete, the AI outputs:
+
+```
+<promise>DONE</promise>
+```
+
+This signals the loop to stop. The AI should ONLY output this when the task is truly complete.
+
+## State File
+
+Located at `.opencode/auto-loop.local.md` (add to `.gitignore`):
+
+```markdown
+---
+active: true
+iteration: 3
+maxIterations: 100
+sessionId: ses_abc123
+---
+
+Your original task prompt
+
+## Completed
+- [x] Set up project structure
+
+## Next Steps
+- [ ] Add authentication
+```
+
+## Credits
+
+- Inspired by [Anthropic's auto-continue plugin](https://github.com/anthropics/claude-code/tree/main/plugins/ralph-wiggum) for Claude Code
+- Based on [opencode-auto-loop](https://github.com/timmyjl12/opencode-auto-loop)

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

@@ -0,0 +1,42 @@
+---
+name: cancel-auto-loop
+description: Cancel active Auto Loop
+---
+
+# Cancel Loop
+
+Stop an active Auto Loop before completion.
+
+## How to Use
+
+When you invoke this skill:
+
+1. First, check if a loop is active:
+
+```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.
+
+## When to Use
+
+Use this command when:
+- The task requirements have changed
+- You want to restart with different parameters
+- The loop appears stuck and you want manual control
+- You need to work on something else
+
+Note: Prefer completing tasks properly with `<promise>DONE</promise>` when possible.

package/src/index.ts

@@ -0,0 +1,596 @@
+import { type Plugin, type PluginInput, tool } from "@opencode-ai/plugin";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+  cpSync,
+} from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+
+// Types
+interface LoopState {
+  active: boolean;
+  iteration: number;
+  maxIterations: number;
+  sessionId?: string;
+  prompt?: string;
+  completed?: string;
+  nextSteps?: string;
+}
+
+type LogLevel = "debug" | "info" | "warn" | "error";
+type LogFn = (level: LogLevel, message: string) => void;
+type OpencodeClient = PluginInput["client"];
+
+// Constants
+const SERVICE_NAME = "auto-loop";
+const STATE_FILENAME = "auto-loop.local.md";
+const OPENCODE_CONFIG_DIR = join(homedir(), ".config/opencode");
+const COMPLETION_TAG = /<promise>\s*DONE\s*<\/promise>/is;
+const DEBOUNCE_MS = 2000;
+
+// Get plugin root directory (ESM only — package is "type": "module")
+function getPluginRoot(): string {
+  const __filename = fileURLToPath(import.meta.url);
+  return dirname(dirname(__filename)); // Go up from src/ to plugin root
+}
+
+// Content-aware copy: always update if content differs
+function copyIfChanged(src: string, dest: string): void {
+  if (!existsSync(src)) return;
+  if (existsSync(dest)) {
+    const srcContent = readFileSync(src, "utf-8");
+    const destContent = readFileSync(dest, "utf-8");
+    if (srcContent === destContent) return;
+  }
+  const destDir = dirname(dest);
+  mkdirSync(destDir, { recursive: true });
+  cpSync(src, dest, { recursive: true });
+}
+
+// Auto-copy skills and commands to opencode config, updating if content changed
+function setupSkillsAndCommands(log: LogFn): void {
+  const pluginRoot = getPluginRoot();
+  const skillsDir = join(OPENCODE_CONFIG_DIR, "skill");
+  const commandsDir = join(OPENCODE_CONFIG_DIR, "command");
+
+  // Copy skills
+  const pluginSkillsDir = join(pluginRoot, "skills");
+  if (existsSync(pluginSkillsDir)) {
+    const skills = ["auto-loop", "cancel-auto-loop", "auto-loop-help"];
+    for (const skill of skills) {
+      const srcFile = join(pluginSkillsDir, skill, "SKILL.md");
+      const destFile = join(skillsDir, skill, "SKILL.md");
+      try {
+        copyIfChanged(srcFile, destFile);
+      } catch (err) {
+        log("warn", `Failed to copy skill '${skill}': ${err}`);
+      }
+    }
+  }
+
+  // Copy commands
+  const pluginCommandsDir = join(pluginRoot, "commands");
+  if (existsSync(pluginCommandsDir)) {
+    const commands = ["auto-loop.md", "cancel-auto-loop.md", "auto-loop-help.md"];
+    for (const cmd of commands) {
+      try {
+        copyIfChanged(join(pluginCommandsDir, cmd), join(commandsDir, cmd));
+      } catch (err) {
+        log("warn", `Failed to copy command '${cmd}': ${err}`);
+      }
+    }
+  }
+}
+
+// Get state file path (project-relative)
+function getStateFile(directory: string): string {
+  return join(directory, ".opencode", STATE_FILENAME);
+}
+
+// Parse markdown frontmatter state
+function parseState(content: string): LoopState {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { active: false, iteration: 0, maxIterations: 100 };
+
+  const frontmatter = match[1];
+  const state: LoopState = {
+    active: false,
+    iteration: 0,
+    maxIterations: 100,
+  };
+
+  for (const line of frontmatter.split("\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) || 100;
+    if (key === "sessionId") state.sessionId = value || undefined;
+  }
+
+  // Get prompt and progress sections from body (after frontmatter)
+  const body = content.slice(match[0].length).trim();
+  if (body) {
+    // Split body at ## Completed / ## Next Steps section boundaries
+    const parts = body.split(/^(?=## (?:Completed|Next Steps))/m);
+
+    // First part is always the original prompt
+    state.prompt = parts[0].trim();
+
+    // Remaining parts are the progress sections
+    for (let i = 1; i < parts.length; i++) {
+      const section = parts[i];
+      if (section.startsWith("## Completed")) {
+        state.completed = section.replace(/^## Completed\n?/, "").trim();
+      } else if (section.startsWith("## Next Steps")) {
+        state.nextSteps = section.replace(/^## Next Steps\n?/, "").trim();
+      }
+    }
+  }
+
+  return state;
+}
+
+// Serialize state to markdown frontmatter with progress sections
+function serializeState(state: LoopState): string {
+  const lines = [
+    "---",
+    `active: ${state.active}`,
+    `iteration: ${state.iteration}`,
+    `maxIterations: ${state.maxIterations}`,
+  ];
+  if (state.sessionId) lines.push(`sessionId: ${state.sessionId}`);
+  lines.push("---");
+  if (state.prompt) lines.push("", state.prompt);
+  if (state.completed) lines.push("", "## Completed", state.completed);
+  if (state.nextSteps) lines.push("", "## Next Steps", state.nextSteps);
+  return lines.join("\n");
+}
+
+// Read state from project directory
+function readState(directory: string): LoopState {
+  const stateFile = getStateFile(directory);
+  if (existsSync(stateFile)) {
+    return parseState(readFileSync(stateFile, "utf-8"));
+  }
+  return { active: false, iteration: 0, maxIterations: 100 };
+}
+
+// Write state to project directory
+function writeState(directory: string, state: LoopState, log: LogFn): void {
+  try {
+    const stateFile = getStateFile(directory);
+    mkdirSync(dirname(stateFile), { recursive: true });
+    writeFileSync(stateFile, serializeState(state));
+  } catch (err) {
+    log("error", `Failed to write state: ${err}`);
+  }
+}
+
+// Clear state
+function clearState(directory: string, log: LogFn): void {
+  try {
+    const stateFile = getStateFile(directory);
+    if (existsSync(stateFile)) unlinkSync(stateFile);
+  } catch (err) {
+    log("warn", `Failed to clear state: ${err}`);
+  }
+}
+
+// Strip markdown code fences before checking for completion tag
+function stripCodeFences(text: string): string {
+  return text.replace(/```[\s\S]*?```/g, "");
+}
+
+// Extract text from the last assistant message in a session
+async function getLastAssistantText(
+  client: OpencodeClient,
+  sessionId: string,
+  directory: string,
+  log: LogFn
+): Promise<string | null> {
+  try {
+    const response = await client.session.messages({
+      path: { id: sessionId },
+      query: { directory },
+    });
+
+    const messages = response.data ?? [];
+
+    const assistantMessages = messages.filter(
+      (msg) => msg.info?.role === "assistant"
+    );
+
+    if (assistantMessages.length === 0) return null;
+
+    const lastAssistant = assistantMessages[assistantMessages.length - 1];
+    const parts = lastAssistant.parts || [];
+
+    return parts
+      .filter((p) => p.type === "text")
+      .map((p) => ("text" in p ? p.text : "") ?? "")
+      .join("\n");
+  } catch (err) {
+    log("warn", `Failed to fetch session messages: ${err}`);
+    return null;
+  }
+}
+
+// Check completion by looking for <promise>DONE</promise> in last assistant text
+function checkCompletion(text: string): boolean {
+  return COMPLETION_TAG.test(stripCodeFences(text));
+}
+
+// Extract next steps / TODOs from assistant message text
+// Looks for common patterns: ## Next Steps, ## TODO, checkbox lists, numbered lists after keywords
+function extractNextSteps(text: string): string | undefined {
+  // Strategy 1: Look for an explicit ## Next Steps / ## TODO / ## Remaining section
+  const sectionMatch = text.match(
+    /^##\s*(?:Next Steps|TODO|Remaining|What's Left|Still To Do|Outstanding)[^\n]*\n([\s\S]*?)(?=\n## |\n\n---|$)/im
+  );
+  if (sectionMatch) {
+    const content = sectionMatch[1].trim();
+    if (content) return content;
+  }
+
+  // Strategy 2: Collect all unchecked checkbox items (- [ ] ...)
+  const unchecked = text
+    .split("\n")
+    .filter((line) => /^\s*-\s*\[ \]/.test(line))
+    .map((line) => line.trim());
+  if (unchecked.length > 0) {
+    return unchecked.join("\n");
+  }
+
+  // Strategy 3: Look for a numbered list after "next" or "todo" or "remaining" keywords
+  const numberedMatch = text.match(
+    /(?:next|todo|remaining|still need to|still to do)[^\n]*\n((?:\s*\d+\.\s+[^\n]+\n?)+)/i
+  );
+  if (numberedMatch) {
+    return numberedMatch[1].trim();
+  }
+
+  return undefined;
+}
+
+// Extract completed items from assistant message text
+function extractCompleted(text: string): string | undefined {
+  // Strategy 1: Look for an explicit ## Completed / ## Done / ## Progress section
+  const sectionMatch = text.match(
+    /^##\s*(?:Completed|Done|Progress|Accomplished|Finished)[^\n]*\n([\s\S]*?)(?=\n## |\n\n---|$)/im
+  );
+  if (sectionMatch) {
+    const content = sectionMatch[1].trim();
+    if (content) return content;
+  }
+
+  // Strategy 2: Collect all checked checkbox items (- [x] ...)
+  const checked = text
+    .split("\n")
+    .filter((line) => /^\s*-\s*\[x\]/i.test(line))
+    .map((line) => line.trim());
+  if (checked.length > 0) {
+    return checked.join("\n");
+  }
+
+  return undefined;
+}
+
+// Merge completed items: deduplicate by normalizing checkbox text
+function mergeCompleted(
+  existing: string | undefined,
+  incoming: string | undefined
+): string | undefined {
+  if (!existing && !incoming) return undefined;
+  if (!existing) return incoming;
+  if (!incoming) return existing;
+
+  const existingLines = existing.split("\n").map((l) => l.trim()).filter(Boolean);
+  const incomingLines = incoming.split("\n").map((l) => l.trim()).filter(Boolean);
+
+  // Normalize for dedup: strip checkbox prefix and lowercase
+  const normalize = (line: string) =>
+    line.replace(/^-\s*\[x\]\s*/i, "").trim().toLowerCase();
+  const existingSet = new Set(existingLines.map(normalize));
+
+  for (const line of incomingLines) {
+    if (!existingSet.has(normalize(line))) {
+      existingLines.push(line);
+      existingSet.add(normalize(line));
+    }
+  }
+
+  return existingLines.join("\n");
+}
+
+// Build a progress section for the continuation prompt
+function buildProgressSection(state: LoopState): string {
+  const sections: string[] = [];
+
+  if (state.completed) {
+    sections.push(`\n## Completed So Far\n${state.completed}`);
+  }
+  if (state.nextSteps) {
+    sections.push(`\n## Next Steps (pick up here)\n${state.nextSteps}`);
+  }
+  if (sections.length === 0) {
+    sections.push(
+      "\nNo structured progress recorded yet. Review your work so far and continue."
+    );
+  }
+
+  return sections.join("\n");
+}
+
+// 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}
+When the task is FULLY complete, you MUST output: <promise>DONE</promise>
+Before going idle, list your progress using ## Completed and ## Next Steps sections.
+Do NOT output false completion promises. If blocked, explain the blocker.`;
+}
+
+// Main plugin
+export const AutoLoopPlugin: Plugin = async (ctx) => {
+  const directory = ctx.directory || process.cwd();
+  const client = ctx.client;
+
+  // Structured logger using the SDK's app.log API
+  const log: LogFn = (level, message) => {
+    try {
+      client.app.log({
+        body: { service: SERVICE_NAME, level, message },
+      });
+    } catch {
+      // Last resort: if logging itself fails, silently ignore
+    }
+  };
+
+  // Toast helper using the SDK's tui.showToast API
+  const toast = (message: string, variant: "info" | "success" | "warning" | "error" = "info") => {
+    try {
+      client.tui.showToast({
+        body: { message, variant },
+      });
+    } catch {
+      // Non-critical — ignore
+    }
+  };
+
+  // Auto-setup skills and commands
+  setupSkillsAndCommands(log);
+
+  // Debounce tracking for idle events
+  let lastContinuation = 0;
+
+  return {
+    tool: {
+      "auto-loop": tool({
+        description:
+          "Start Auto Loop — auto-continues until task completion. Use: /auto-loop <task description>",
+        args: {
+          task: tool.schema
+            .string()
+            .describe("The task to work on until completion"),
+          maxIterations: tool.schema
+            .number()
+            .optional()
+            .describe("Maximum iterations (default: 100)"),
+        },
+        async execute({ task, maxIterations = 100 }, context) {
+          const state: LoopState = {
+            active: true,
+            iteration: 0,
+            maxIterations,
+            sessionId: context.sessionID,
+            prompt: task,
+          };
+          writeState(directory, state, log);
+
+          log("info", `Loop started for session ${context.sessionID}`);
+          toast(`Auto Loop started (max ${maxIterations} iterations)`, "success");
+
+          return `Auto Loop started (max ${maxIterations} iterations).
+
+Task: ${task}
+
+I will auto-continue until the task is complete. Before going idle each iteration, I will output structured progress:
+
+\`\`\`
+## Completed
+- [x] What I finished
+
+## Next Steps
+- [ ] What remains (in priority order)
+\`\`\`
+
+When fully done, I will output \`<promise>DONE</promise>\` to signal completion.
+
+Use /cancel-auto-loop to stop early.`;
+        },
+      }),
+
+      "cancel-auto-loop": tool({
+        description: "Cancel active Auto Loop",
+        args: {},
+        async execute() {
+          const state = readState(directory);
+          if (!state.active) {
+            return "No active Auto Loop to cancel.";
+          }
+          const iterations = state.iteration;
+          clearState(directory, log);
+
+          log("info", `Loop cancelled after ${iterations} iteration(s)`);
+          toast(`Auto Loop cancelled after ${iterations} iteration(s)`, "warning");
+
+          return `Auto Loop cancelled after ${iterations} iteration(s).`;
+        },
+      }),
+
+      "auto-loop-help": tool({
+        description: "Show Auto Loop plugin help",
+        args: {},
+        async execute() {
+          return `# Auto Loop Help
+
+## Available Commands
+
+- \`/auto-loop <task>\` - Start an auto-continuation loop
+- \`/cancel-auto-loop\` - Stop an active loop
+- \`/auto-loop-help\` - Show this help
+
+## How It Works
+
+1. Start with: /auto-loop "Build a REST API"
+2. AI works on the task until idle
+3. Plugin auto-continues if not complete
+4. Loop stops when AI outputs: <promise>DONE</promise>
+
+## State File
+
+Located at: .opencode/auto-loop.local.md`;
+        },
+      }),
+    },
+
+    // Event hooks for auto-continuation, compaction recovery, and lifecycle
+    event: async ({ event }) => {
+      // --- session.idle: core auto-continuation logic ---
+      if (event.type === "session.idle") {
+        const now = Date.now();
+        if (now - lastContinuation < DEBOUNCE_MS) return;
+
+        const sessionId = event.properties.sessionID;
+        const state = readState(directory);
+
+        if (!state.active) return;
+        if (!sessionId) return;
+        if (state.sessionId && state.sessionId !== sessionId) return;
+
+        // Fetch last assistant message (used for completion check + progress extraction)
+        const lastText = await getLastAssistantText(client, sessionId, directory, log);
+
+        if (lastText && checkCompletion(lastText)) {
+          clearState(directory, log);
+          log("info", `Loop completed at iteration ${state.iteration}`);
+          toast(`Auto Loop completed after ${state.iteration} iteration(s)`, "success");
+          return;
+        }
+
+        if (state.iteration >= state.maxIterations) {
+          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;
+
+        const newState: LoopState = {
+          ...state,
+          iteration: state.iteration + 1,
+          sessionId,
+          // Update next steps if we found new ones, otherwise keep previous
+          nextSteps: newNextSteps || state.nextSteps,
+          // Merge completed: append new completed items to existing
+          completed: mergeCompleted(state.completed, newCompleted),
+        };
+        writeState(directory, newState, log);
+        lastContinuation = Date.now();
+
+        // Build continuation prompt with progress context
+        const progressSection = buildProgressSection(newState);
+
+        const continuationPrompt = `[AUTO LOOP — ITERATION ${newState.iteration}/${newState.maxIterations}]
+
+Continue working on the task. Do NOT repeat work that is already done.
+${progressSection}
+IMPORTANT:
+- Pick up from the next incomplete step below
+- When FULLY complete, output: <promise>DONE</promise>
+- Before going idle, list your progress using ## Completed and ## Next Steps sections
+- Do not stop until the task is truly done
+
+Original task:
+${state.prompt || "(no task specified)"}`;
+
+        try {
+          await client.session.prompt({
+            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}`);
+        }
+      }
+
+      // --- session.compacted: re-inject loop context after compaction ---
+      if (event.type === "session.compacted") {
+        const sessionId = event.properties.sessionID;
+        const state = readState(directory);
+
+        if (!state.active) return;
+        if (state.sessionId && state.sessionId !== sessionId) return;
+
+        // After compaction, the AI loses loop context — send a reminder
+        try {
+          await client.session.prompt({
+            path: { id: sessionId },
+            body: {
+              parts: [{ type: "text", text: buildLoopContextReminder(state) }],
+            },
+          });
+          log("info", `Re-injected loop context after compaction for session ${sessionId}`);
+        } catch (err) {
+          log("warn", `Failed to re-inject loop context after compaction: ${err}`);
+        }
+      }
+
+      // --- session.error: pause the loop on error ---
+      if (event.type === "session.error") {
+        const sessionId = event.properties.sessionID;
+        const state = readState(directory);
+
+        if (
+          state.active &&
+          (!state.sessionId || state.sessionId === sessionId)
+        ) {
+          log("warn", `Session error detected, pausing loop at iteration ${state.iteration}`);
+          toast("Auto Loop paused — session error", "error");
+          // Mark inactive but keep state so user can inspect/resume
+          writeState(directory, { ...state, active: false }, log);
+        }
+      }
+
+      // --- session.deleted: clean up if it's our session ---
+      if (event.type === "session.deleted") {
+        const state = readState(directory);
+        if (!state.active) return;
+
+        const deletedSessionId = event.properties.info?.id;
+        if (state.sessionId && deletedSessionId && state.sessionId !== deletedSessionId) return;
+
+        clearState(directory, log);
+        log("info", "Session deleted, cleaning up loop state");
+      }
+    },
+  };
+};
+
+export default AutoLoopPlugin;