open-plan-annotator 0.2.5 → 0.2.6

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "open-plan-annotator",
       "source": "./",
       "description": "Interactive plan annotation UI: review, strikethrough, and comment on Claude's plans before approving. Fully local, no external services.",
-      "version": "0.2.5",
+      "version": "0.2.6",
       "author": {
         "name": "ndom91"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "open-plan-annotator",
   "description": "Interactive plan annotation UI: review, strikethrough, and comment on Claude's plans before approving. Fully local, no external services.",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "author": {
     "name": "ndom91"
   },

package/README.md

@@ -18,7 +18,7 @@ Select text to <code style="color: purple">strikethrough</code>, <code style="co
 2. An ephemeral HTTP server starts and opens a React UI in your browser
 3. You review and annotate the plan
 4. **Approve** or **Request Changes**
-5. The tool returns host-specific JSON output (Claude hook output or OpenCode plugin output)
+5. The tool returns structured JSON output back to the host
 
 The server shuts down after you decide. Everything runs locally, nothing leaves your machine.
 
@@ -57,34 +57,35 @@ This registers the `ExitPlanMode` hook that launches the annotation UI.
 
 ### OpenCode
 
-The OpenCode plugin uses the `@opencode-ai/plugin` SDK to register a `submit_plan` tool and inject system prompt instructions that tell the agent to use plan mode.
+Add `open-plan-annotator` to the `plugin` array in your OpenCode config (`opencode.json` or `.opencode/config.json`):
 
-**Option A: Install from npm (recommended)**
-
-```sh
-npm install -g open-plan-annotator
-cd /path/to/your/project
-open-plan-annotator-install-opencode
+```json
+{
+  "plugin": ["open-plan-annotator"]
+}
 ```
 
-This installs the plugin to `~/.config/opencode/plugins/open-plan-annotator/`, installs dependencies, and creates a loader shim that OpenCode auto-discovers — no config changes needed.
-
-**Option B: From source**
-
-```sh
-git clone https://github.com/ndom91/open-plan-annotator.git
-cd open-plan-annotator
-bun install
-bun run install:opencode-plugin   # installs to .opencode/plugins/ in CWD
-```
-
-The install script creates the auto-discovery shim, so no config changes needed.
-
-The plugin automatically:
+OpenCode will install the package and load it automatically. The plugin:
 - Injects plan-mode instructions into the agent's system prompt
 - Registers a `submit_plan` tool that the agent calls after creating a plan
 - Spawns the annotation UI in your browser for review
 - Returns structured feedback to the agent on approval or rejection
+- Optionally hands off to an implementation agent after approval
+
+#### Implementation handoff
+
+By default, after a plan is approved the plugin sends "Proceed with implementation." to a `build` agent. To customize or disable this, create `open-plan-annotator.json` in your project's `.opencode/` directory or globally in `~/.config/opencode/`:
+
+```json
+{
+  "implementationHandoff": {
+    "enabled": true,
+    "agent": "build"
+  }
+}
+```
+
+Set `enabled` to `false` to disable auto-handoff. Project config overrides global config.
 
 ### From source (Claude Code)
 

package/opencode/bridge.js

@@ -0,0 +1,166 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+const WRAPPER_PATH = fileURLToPath(new URL("../bin/open-plan-annotator.cjs", import.meta.url));
+
+/**
+ * @typedef {{
+ *   hookSpecificOutput: {
+ *     hookEventName: "PermissionRequest",
+ *     decision: { behavior: "allow" } | { behavior: "deny", message: string }
+ *   }
+ * }} HookOutput
+ */
+
+/**
+ * @param {{ plan: string, sessionId?: string, cwd?: string }} options
+ */
+function buildHookPayload(options) {
+  return {
+    session_id: options.sessionId ?? randomUUID(),
+    transcript_path: "",
+    cwd: options.cwd ?? process.cwd(),
+    permission_mode: "default",
+    hook_event_name: "PermissionRequest",
+    tool_name: "ExitPlanMode",
+    tool_use_id: randomUUID(),
+    tool_input: {
+      plan: options.plan,
+    },
+  };
+}
+
+/**
+ * @param {string} stdoutText
+ * @param {string} stderrText
+ * @returns {HookOutput}
+ */
+function parseHookOutput(stdoutText, stderrText) {
+  const trimmed = stdoutText.trim();
+  if (!trimmed) {
+    const stderr = stderrText.trim();
+    throw new Error(
+      stderr
+        ? `open-plan-annotator returned empty stdout; stderr: ${stderr}`
+        : "open-plan-annotator returned empty stdout",
+    );
+  }
+
+  try {
+    return validateHookOutput(JSON.parse(trimmed));
+  } catch {
+    const lines = trimmed
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .reverse();
+
+    for (const line of lines) {
+      try {
+        return validateHookOutput(JSON.parse(line));
+      } catch {
+        // ignore and keep searching
+      }
+    }
+
+    throw new Error("open-plan-annotator returned invalid hook JSON");
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @returns {HookOutput}
+ */
+function validateHookOutput(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("invalid hook output shape");
+  }
+
+  const output = /** @type {HookOutput} */ (value);
+  const decision = output?.hookSpecificOutput?.decision;
+
+  if (!decision || typeof decision !== "object" || typeof decision.behavior !== "string") {
+    throw new Error("missing decision in hook output");
+  }
+
+  if (decision.behavior === "allow") {
+    return output;
+  }
+
+  if (decision.behavior === "deny" && typeof decision.message === "string") {
+    return output;
+  }
+
+  throw new Error("unsupported decision payload");
+}
+
+/**
+ * @param {{ plan: string, sessionId?: string, cwd?: string }} options
+ */
+export async function runPlanReview(options) {
+  const payload = buildHookPayload(options);
+
+  const result = await new Promise((resolve, reject) => {
+    const child = spawn(WRAPPER_PATH, [], {
+      cwd: options.cwd ?? process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+
+    child.on("error", (error) => {
+      reject(error);
+    });
+
+    child.on("close", (code, signal) => {
+      resolve({ code, signal, stdout, stderr });
+    });
+
+    child.stdin.write(`${JSON.stringify(payload)}\n`);
+    child.stdin.end();
+  });
+
+  const settled =
+    /** @type {{ code: number | null, signal: NodeJS.Signals | null, stdout: string, stderr: string }} */ (result);
+
+  if (settled.signal) {
+    const errorText = settled.stderr.trim();
+    throw new Error(
+      errorText
+        ? `open-plan-annotator was terminated by signal ${settled.signal}: ${errorText}`
+        : `open-plan-annotator was terminated by signal ${settled.signal}`,
+    );
+  }
+
+  if (settled.code !== 0) {
+    const errorText = settled.stderr.trim();
+    throw new Error(
+      errorText
+        ? `open-plan-annotator exited with code ${settled.code}: ${errorText}`
+        : `open-plan-annotator exited with code ${settled.code}`,
+    );
+  }
+
+  const output = parseHookOutput(settled.stdout, settled.stderr);
+  const decision = output.hookSpecificOutput.decision;
+
+  if (decision.behavior === "allow") {
+    return { approved: true };
+  }
+
+  return {
+    approved: false,
+    feedback: decision.message,
+  };
+}

package/opencode/config.js

@@ -0,0 +1,79 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CONFIG_FILE_NAME = "open-plan-annotator.json";
+const DEFAULT_HANDOFF_ENABLED = true;
+const DEFAULT_IMPLEMENTATION_AGENT = "build";
+
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+async function readConfigFile(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveConfigBaseDir() {
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim();
+  if (xdgConfigHome) {
+    return xdgConfigHome;
+  }
+
+  const homeDir = homedir()?.trim();
+  if (homeDir) {
+    return join(homeDir, ".config");
+  }
+
+  return undefined;
+}
+
+function parseImplementationHandoff(config) {
+  if (!isRecord(config)) {
+    return {};
+  }
+
+  const raw = config.implementationHandoff;
+  if (!isRecord(raw)) {
+    return {};
+  }
+
+  const enabled = typeof raw.enabled === "boolean" ? raw.enabled : undefined;
+
+  let agent;
+  if (typeof raw.agent === "string") {
+    const trimmed = raw.agent.trim();
+    if (trimmed) {
+      agent = trimmed;
+    }
+  }
+
+  return { enabled, agent };
+}
+
+export async function resolveImplementationHandoff(directory) {
+  const globalConfigDir = resolveConfigBaseDir();
+  const globalConfigPath = globalConfigDir ? join(globalConfigDir, "opencode", CONFIG_FILE_NAME) : undefined;
+  const projectConfigPath = directory ? join(directory, ".opencode", CONFIG_FILE_NAME) : undefined;
+
+  const globalConfig = globalConfigPath ? parseImplementationHandoff(await readConfigFile(globalConfigPath)) : {};
+  const projectConfig = projectConfigPath ? parseImplementationHandoff(await readConfigFile(projectConfigPath)) : {};
+
+  const enabled = projectConfig.enabled ?? globalConfig.enabled ?? DEFAULT_HANDOFF_ENABLED;
+  const agent = projectConfig.agent ?? globalConfig.agent ?? DEFAULT_IMPLEMENTATION_AGENT;
+
+  return {
+    enabled,
+    agent,
+    paths: {
+      global: globalConfigPath,
+      project: projectConfigPath,
+    },
+  };
+}

package/opencode/config.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveImplementationHandoff } from "./config.js";
+
+function withEnv(key: string, value: string | undefined, fn: () => Promise<void>) {
+  const original = process.env[key];
+  if (value === undefined) {
+    delete process.env[key];
+  } else {
+    process.env[key] = value;
+  }
+
+  return fn().finally(() => {
+    if (original === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = original;
+    }
+  });
+}
+
+describe("resolveImplementationHandoff", () => {
+  test("returns defaults when no config files exist", async () => {
+    const tempRoot = mkdtempSync(join(tmpdir(), "open-plan-annotator-config-"));
+
+    try {
+      await withEnv("XDG_CONFIG_HOME", join(tempRoot, "xdg"), async () => {
+        const result = await resolveImplementationHandoff(join(tempRoot, "project"));
+        expect(result.enabled).toBe(true);
+        expect(result.agent).toBe("build");
+      });
+    } finally {
+      rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("uses global config when project config is missing", async () => {
+    const tempRoot = mkdtempSync(join(tmpdir(), "open-plan-annotator-config-"));
+    const xdgHome = join(tempRoot, "xdg");
+    const globalConfigDir = join(xdgHome, "opencode");
+    mkdirSync(globalConfigDir, { recursive: true });
+    writeFileSync(
+      join(globalConfigDir, "open-plan-annotator.json"),
+      JSON.stringify({ implementationHandoff: { enabled: false, agent: "explore" } }),
+      "utf8",
+    );
+
+    try {
+      await withEnv("XDG_CONFIG_HOME", xdgHome, async () => {
+        const result = await resolveImplementationHandoff(join(tempRoot, "project"));
+        expect(result.enabled).toBe(false);
+        expect(result.agent).toBe("explore");
+      });
+    } finally {
+      rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("project config overrides global config", async () => {
+    const tempRoot = mkdtempSync(join(tmpdir(), "open-plan-annotator-config-"));
+    const xdgHome = join(tempRoot, "xdg");
+    const globalConfigDir = join(xdgHome, "opencode");
+    const projectDir = join(tempRoot, "project");
+    const projectConfigDir = join(projectDir, ".opencode");
+
+    mkdirSync(globalConfigDir, { recursive: true });
+    mkdirSync(projectConfigDir, { recursive: true });
+
+    writeFileSync(
+      join(globalConfigDir, "open-plan-annotator.json"),
+      JSON.stringify({ implementationHandoff: { enabled: true, agent: "explore" } }),
+      "utf8",
+    );
+    writeFileSync(
+      join(projectConfigDir, "open-plan-annotator.json"),
+      JSON.stringify({ implementationHandoff: { enabled: false, agent: "build" } }),
+      "utf8",
+    );
+
+    try {
+      await withEnv("XDG_CONFIG_HOME", xdgHome, async () => {
+        const result = await resolveImplementationHandoff(projectDir);
+        expect(result.enabled).toBe(false);
+        expect(result.agent).toBe("build");
+      });
+    } finally {
+      rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("ignores malformed config and falls back", async () => {
+    const tempRoot = mkdtempSync(join(tmpdir(), "open-plan-annotator-config-"));
+    const xdgHome = join(tempRoot, "xdg");
+    const globalConfigDir = join(xdgHome, "opencode");
+    mkdirSync(globalConfigDir, { recursive: true });
+    writeFileSync(join(globalConfigDir, "open-plan-annotator.json"), "not-json", "utf8");
+
+    try {
+      await withEnv("XDG_CONFIG_HOME", xdgHome, async () => {
+        const result = await resolveImplementationHandoff(join(tempRoot, "project"));
+        expect(result.enabled).toBe(true);
+        expect(result.agent).toBe("build");
+      });
+    } finally {
+      rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+});

package/opencode/index.js

@@ -0,0 +1,184 @@
+import { tool } from "@opencode-ai/plugin";
+import { runPlanReview } from "./bridge.js";
+import { resolveImplementationHandoff } from "./config.js";
+
+const PLAN_REVIEW_INSTRUCTIONS = `## Plan Review Workflow
+
+For non-trivial implementation work, create a plan first and call the \`submit_plan\` tool.
+The user will review the plan in a browser and either approve it or request changes.
+
+- If approved, proceed with implementation.
+- If changes are requested, revise the plan and call \`submit_plan\` again.
+
+Do not begin implementation until the plan is approved.`;
+
+const IMPLEMENTATION_PROMPT = "Proceed with implementation.";
+
+function getErrorMessage(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return "unknown error";
+}
+
+/** @type {import("@opencode-ai/plugin").Plugin} */
+export const OpenPlanAnnotatorPlugin = async (ctx) => {
+  const implementationHandoff = await resolveImplementationHandoff(ctx.directory);
+  const implementationAgent = implementationHandoff.enabled ? implementationHandoff.agent : undefined;
+
+  async function getCurrentUserAgent(sessionID) {
+    if (!sessionID) {
+      return undefined;
+    }
+
+    const response = await ctx.client.session.messages({
+      path: { id: sessionID },
+    });
+
+    const messages = response?.data;
+    if (!Array.isArray(messages)) {
+      return undefined;
+    }
+
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+      const message = messages[i];
+      if (message?.info?.role === "user") {
+        return message?.info?.agent;
+      }
+    }
+
+    return undefined;
+  }
+
+  async function shouldInjectPlanReviewInstructions(sessionID) {
+    if (!sessionID) {
+      return true;
+    }
+
+    try {
+      const currentAgent = await getCurrentUserAgent(sessionID);
+      if (!currentAgent) {
+        return true;
+      }
+
+      if (implementationAgent && currentAgent === implementationAgent) {
+        return false;
+      }
+
+      const response = await ctx.client.app.agents({
+        query: { directory: ctx.directory },
+      });
+      const agents = response?.data;
+      if (!Array.isArray(agents)) {
+        return true;
+      }
+
+      const agent = agents.find((candidate) => candidate.name === currentAgent);
+      if (agent?.mode === "subagent") {
+        return false;
+      }
+    } catch {
+      return true;
+    }
+
+    return true;
+  }
+
+  async function handoffToImplementationAgent(sessionID) {
+    if (!implementationAgent) {
+      return null;
+    }
+
+    if (!sessionID) {
+      return {
+        agent: implementationAgent,
+        warning: "Could not auto-switch because the current session ID was unavailable.",
+      };
+    }
+
+    try {
+      await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          agent: implementationAgent,
+          noReply: true,
+          parts: [{ type: "text", text: IMPLEMENTATION_PROMPT }],
+        },
+      });
+
+      return { agent: implementationAgent };
+    } catch (error) {
+      return {
+        agent: implementationAgent,
+        warning: `Could not auto-switch to \`${implementationAgent}\`: ${getErrorMessage(error)}`,
+      };
+    }
+  }
+
+  return {
+    "experimental.chat.system.transform": async (input, output) => {
+      const currentSystem = output.system.join("\n").toLowerCase();
+      if (currentSystem.includes("title generator") || currentSystem.includes("generate a concise title")) {
+        return;
+      }
+
+      if (!currentSystem.includes("submit_plan")) {
+        const shouldInject = await shouldInjectPlanReviewInstructions(input?.sessionID);
+        if (shouldInject) {
+          output.system.push(PLAN_REVIEW_INSTRUCTIONS);
+        }
+      }
+    },
+
+    tool: {
+      submit_plan: tool({
+        description:
+          "Submit a markdown plan for interactive user review. Returns approval status or structured revision feedback.",
+
+        args: {
+          plan: tool.schema.string().describe("The complete implementation plan in markdown format"),
+          summary: tool.schema.string().optional().describe("Optional one-line plan summary"),
+        },
+
+        async execute(args, context) {
+          const result = await runPlanReview({
+            plan: args.plan,
+            sessionId: context.sessionID,
+          });
+
+          if (result.approved) {
+            const lines = ["Plan approved by the user."];
+
+            if (args.summary) {
+              lines.push(`Summary: ${args.summary}`);
+            }
+
+            const handoffResult = await handoffToImplementationAgent(context.sessionID);
+            if (handoffResult) {
+              if (handoffResult.warning) {
+                lines.push(`Auto-switch warning: ${handoffResult.warning}`);
+              } else {
+                lines.push(`Auto-switched to the \`${handoffResult.agent}\` agent for implementation.`);
+              }
+            }
+
+            lines.push("Proceed with implementation.");
+            return lines.join("\n\n");
+          }
+
+          return [
+            "Plan needs revision.",
+            "",
+            "## User feedback",
+            "",
+            result.feedback ?? "Plan changes requested.",
+            "",
+            "Revise the plan using this feedback, then call `submit_plan` again.",
+          ].join("\n");
+        },
+      }),
+    },
+  };
+};
+
+export default OpenPlanAnnotatorPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-plan-annotator",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "type": "module",
   "description": "Fully local plugin for interactive plan annotation from your Agentic assistants",
   "author": "ndom91",
@@ -17,20 +17,18 @@
     "annotation",
     "code-review"
   ],
+  "main": "opencode/index.js",
   "bin": {
-    "open-plan-annotator": "bin/open-plan-annotator.cjs",
-    "open-plan-annotator-install-opencode": "bin/open-plan-annotator-install-opencode.cjs"
+    "open-plan-annotator": "bin/open-plan-annotator.cjs"
   },
   "files": [
     "bin/open-plan-annotator.cjs",
-    "bin/open-plan-annotator-install-opencode.cjs",
     "install.cjs",
     ".claude-plugin/",
-    "opencode-plugin/",
+    "opencode/",
     "hooks/",
     "CLAUDE.md",
-    "README.md",
-    "scripts/install-opencode-plugin.cjs"
+    "README.md"
   ],
   "scripts": {
     "postinstall": "node install.cjs",
@@ -46,7 +44,6 @@
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "format": "biome format --write .",
-    "install:opencode-plugin": "node scripts/install-opencode-plugin.cjs",
     "do-release": "./scripts/release.sh",
     "prepack": "mv CLAUDE.md CLAUDE.dev.md.bak && cp CLAUDE.plugin.md CLAUDE.md",
     "postpack": "mv CLAUDE.dev.md.bak CLAUDE.md"
@@ -56,6 +53,7 @@
     "@types/bun": "^1.3.9"
   },
   "dependencies": {
+    "@opencode-ai/plugin": "^0.0.3",
     "@types/node": "^25.3.0"
   }
 }

package/bin/open-plan-annotator-install-opencode.cjs

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-require("../scripts/install-opencode-plugin.cjs");

package/opencode-plugin/index.ts

@@ -1,174 +0,0 @@
-import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { type Plugin, tool } from "@opencode-ai/plugin";
-
-function resolveRunner(): { command: string; args: string[] } {
-  const moduleDir = dirname(new URL(import.meta.url).pathname);
-  const repoRoot = join(moduleDir, "..");
-  const sourceServer = join(repoRoot, "server", "index.ts");
-  const packageBin = join(repoRoot, "bin", "open-plan-annotator.cjs");
-  const projectLocal = join(process.cwd(), "node_modules", ".bin", "open-plan-annotator");
-
-  if (existsSync(sourceServer) && process.env.OPEN_PLAN_ANNOTATOR_FORCE_BINARY !== "1") {
-    return { command: "bun", args: ["run", sourceServer] };
-  }
-
-  if (existsSync(packageBin)) {
-    return { command: process.execPath, args: [packageBin] };
-  }
-
-  if (existsSync(projectLocal)) {
-    return { command: projectLocal, args: [] };
-  }
-
-  return { command: "open-plan-annotator", args: [] };
-}
-
-function execAsync(
-  command: string,
-  args: string[],
-  stdinData: string,
-): Promise<{ stdout: string; stderr: string; status: number | null }> {
-  return new Promise((resolve) => {
-    const child = execFile(
-      command,
-      args,
-      { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 },
-      (error, stdout, stderr) => {
-        resolve({
-          stdout: stdout ?? "",
-          stderr: stderr ?? "",
-          status: error ? 1 : 0,
-        });
-      },
-    );
-    if (child.stdin) {
-      child.stdin.write(stdinData);
-      child.stdin.end();
-    }
-  });
-}
-
-function normalizeOutput(
-  stdout: string,
-  stderr: string,
-  _status: number | null,
-): { ok: boolean; decision: string; feedback?: string; message?: string } {
-  const text = (stdout ?? "").trim();
-  if (!text) {
-    return {
-      ok: false,
-      decision: "deny",
-      feedback: stderr || "open-plan-annotator returned empty output",
-      message: "Plan changes requested.",
-    };
-  }
-
-  try {
-    const parsed = JSON.parse(text);
-    if (parsed && typeof parsed === "object") return parsed;
-  } catch {
-    // fall through
-  }
-
-  return {
-    ok: false,
-    decision: "deny",
-    feedback: `Unexpected response from open-plan-annotator: ${text}`,
-    message: "Plan changes requested.",
-  };
-}
-
-const SYSTEM_INSTRUCTIONS = `
-## Plan Submission
-
-When you have completed your plan, you MUST call the \`submit_plan\` tool to submit it for user review.
-The user will be able to:
-- Review your plan visually in a dedicated UI
-- Annotate specific sections with feedback
-- Approve the plan to proceed with implementation
-- Request changes with detailed feedback
-
-If your plan is rejected, you will receive the user's annotated feedback. Revise your plan
-based on their feedback and call submit_plan again.
-
-Do NOT proceed with implementation until your plan is approved.
-
-### When to Use Plan Mode
-
-Use plan mode (and submit your plan for review) for any task involving:
-- Creating or modifying more than 2 files
-- Architectural or structural changes
-- Anything the user hasn't explicitly described step-by-step
-- Refactoring, migration, or feature additions
-- Bug fixes that require investigation
-
-For truly trivial tasks (fix a typo, rename a single variable, answer a factual question), you may skip plan submission.
-
-### Plan Quality Standards
-
-When writing a plan, include:
-- A brief summary of what you understood the task to require
-- The specific files you intend to create or modify and why
-- Any assumptions you are making
-- An explicit question if anything is ambiguous
-`;
-
-export const OpenPlanAnnotatorPlugin: Plugin = async (_ctx) => {
-  return {
-    "experimental.chat.system.transform": async (_input, output) => {
-      output.system.push(SYSTEM_INSTRUCTIONS);
-    },
-
-    tool: {
-      submit_plan: tool({
-        description:
-          "Submit your completed plan for interactive user review. The user can annotate, approve, or request changes. Call this when you have finished creating your implementation plan.",
-        args: {
-          plan: tool.schema.string().describe("The complete implementation plan in markdown format"),
-          summary: tool.schema
-            .string()
-            .optional()
-            .describe("A brief 1-2 sentence summary of what the plan accomplishes"),
-        },
-
-        async execute(args) {
-          const runner = resolveRunner();
-          const payload = JSON.stringify({
-            host: "opencode",
-            command: "submit_plan",
-            plan: args.plan,
-            cwd: process.cwd(),
-          });
-
-          const result = await execAsync(runner.command, runner.args, payload);
-          const output = normalizeOutput(result.stdout, result.stderr, result.status);
-
-          if (output.ok && output.decision === "approve") {
-            return [
-              "Plan approved by the user. You may now proceed with implementation.",
-              args.summary ? `\nPlan Summary: ${args.summary}` : "",
-            ].join("");
-          }
-
-          return [
-            "Plan needs revision.",
-            "",
-            "The user has requested changes to your plan. Please review their feedback below and revise your plan accordingly.",
-            "",
-            "## User Feedback",
-            "",
-            output.feedback ?? "Plan changes requested.",
-            "",
-            "---",
-            "",
-            "Please revise your plan based on this feedback and call `submit_plan` again when ready.",
-          ].join("\n");
-        },
-      }),
-    },
-  };
-};
-
-export default OpenPlanAnnotatorPlugin;

package/opencode-plugin/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "open-plan-annotator-opencode",
-  "version": "0.2.3",
-  "description": "Open Plan Annotator plugin for OpenCode - interactive plan review with visual annotation",
-  "author": "ndom91",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ndom91/open-plan-annotator.git",
-    "directory": "opencode-plugin"
-  },
-  "main": "index.ts",
-  "files": [
-    "index.ts",
-    "package.json"
-  ],
-  "dependencies": {
-    "@opencode-ai/plugin": "^1.0.218"
-  },
-  "peerDependencies": {
-    "bun": ">=1.0.0"
-  }
-}

package/scripts/install-opencode-plugin.cjs

@@ -1,91 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-const path = require("path");
-
-function resolveTargetRoot() {
-  const fromArg = process.argv[2];
-  if (fromArg && fromArg.trim().length > 0) {
-    return path.resolve(process.cwd(), fromArg);
-  }
-  const configHome = process.env.XDG_CONFIG_HOME || path.join(require("os").homedir(), ".config");
-  return path.join(configHome, "opencode", "plugins");
-}
-
-function ensureParentDir(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-}
-
-function installPlugin(sourceDir, destinationDir) {
-  if (fs.existsSync(destinationDir)) {
-    fs.rmSync(destinationDir, { recursive: true, force: true });
-  }
-
-  try {
-    fs.symlinkSync(sourceDir, destinationDir, "dir");
-    return "symlink";
-  } catch {
-    fs.cpSync(sourceDir, destinationDir, { recursive: true });
-    return "copy";
-  }
-}
-
-function main() {
-  const projectRoot = path.resolve(__dirname, "..");
-  const sourceDir = path.join(projectRoot, "opencode-plugin");
-  const targetRoot = resolveTargetRoot();
-  const destinationDir = path.join(targetRoot, "open-plan-annotator");
-
-  if (!fs.existsSync(sourceDir)) {
-    console.error(`open-plan-annotator: missing opencode-plugin at ${sourceDir}`);
-    process.exit(1);
-  }
-
-  ensureParentDir(targetRoot);
-  const mode = installPlugin(sourceDir, destinationDir);
-
-  console.log(
-    `open-plan-annotator: installed OpenCode plugin (${mode}) at ${destinationDir}`,
-  );
-
-  // Install plugin dependencies using the first available package manager
-  const { execFileSync } = require("child_process");
-  const packageManagers = [
-    { cmd: "bun", args: ["install"] },
-    { cmd: "pnpm", args: ["install"] },
-    { cmd: "npm", args: ["install"] },
-  ];
-
-  let installed = false;
-  for (const pm of packageManagers) {
-    try {
-      execFileSync(pm.cmd, pm.args, { cwd: destinationDir, stdio: "inherit" });
-      installed = true;
-      break;
-    } catch {
-      // Try the next package manager
-    }
-  }
-
-  if (!installed) {
-    console.log(
-      "open-plan-annotator: could not install dependencies automatically. Run `npm install` in:",
-      destinationDir,
-    );
-  }
-
-  // Create wrapper shim at plugins/open-plan-annotator.ts for OpenCode auto-discovery
-  // OpenCode scans plugins/*.{ts,js} but not subdirectories
-  const shimPath = path.join(targetRoot, "open-plan-annotator.ts");
-  fs.writeFileSync(
-    shimPath,
-    `export { default } from "./open-plan-annotator/index.ts";\n`,
-  );
-  console.log(`open-plan-annotator: created loader shim at ${shimPath}`);
-
-  console.log(
-    "\nThe plugin will be auto-discovered by OpenCode — no config changes needed.",
-  );
-}
-
-main();