questionably-ultrathink 1.0.0 → 1.0.1

package/README.md

@@ -12,11 +12,45 @@ UltraThink enhances Claude's reasoning with two research-backed frameworks:
 ## Installation
 
 ```bash
-# Add the marketplace
-/plugin marketplace add snowmead/questionably-ultrathink
+bun add -g questionably-ultrathink
+```
+
+Then run the interactive installer:
+
+```bash
+questionably-ultrathink install
+```
+
+Or install directly to a specific platform:
 
-# Install the plugin
-/plugin install questionably-ultrathink@snowmead-marketplace
+```bash
+questionably-ultrathink install --claude-code   # Claude Code only
+questionably-ultrathink install --opencode      # OpenCode only
+questionably-ultrathink install --both          # Both platforms
+```
+
+**Install locations:**
+- Claude Code: `~/.claude/plugins/questionably-ultrathink/`
+- OpenCode: `~/.config/opencode/`
+
+> **Alternative:** Claude Code users can also install via marketplace:
+> ```bash
+> /plugin marketplace add snowmead/questionably-ultrathink
+> /plugin install questionably-ultrathink@snowmead-marketplace
+> ```
+
+## Usage
+
+### Claude Code
+
+```
+/questionably-ultrathink analyze whether this authentication approach is secure
+```
+
+### OpenCode
+
+```
+@questionably-ultrathink analyze whether this authentication approach is secure
 ```
 
 ## Development Setup
@@ -31,7 +65,7 @@ This installs dependencies (lefthook, comrak) if missing and sets up git hooks f
 
 ## Commands
 
-### `/questionably-ultrathink`
+### `/questionably-ultrathink` (Claude Code) / `@questionably-ultrathink` (OpenCode)
 
 Run the full reasoning pipeline on a problem:
 
@@ -43,10 +77,6 @@ Run the full reasoning pipeline on a problem:
 6. Synthesizes and verifies final response
 7. Iterates if confidence is below threshold (thorough/high-stakes only)
 
-```
-/questionably-ultrathink analyze whether this authentication approach is secure
-```
-
 ### `/decompose`
 
 Break down a complex problem into atomic sub-questions:

package/dist/claude-code/skills/questionably-ultrathink-skill/SKILL.md

@@ -18,6 +18,26 @@ allowed-tools: [Task, Read, Grep, Glob, WebSearch, WebFetch, AskUserQuestion, Ba
 
 You now have access to advanced reasoning agents for rigorous analysis. Use them when problems require more than surface-level analysis.
 
+\<critical\_warning\>
+
+## ⚠️ CRITICAL: DO NOT INVOKE YOURSELF
+
+You ARE the `questionably-ultrathink` orchestrator. You must **NEVER** call:
+
+```
+subagent_type: "questionably-ultrathink"  ← FORBIDDEN (infinite recursion)
+subagent_type: "questionably-ultrathink-skill"  ← FORBIDDEN (infinite recursion)
+```
+
+You can ONLY invoke these subagents:
+
+- `subagent_type: "questionably-ultrathink:atom-of-thoughts"` ← Use this for decomposition
+- `subagent_type: "questionably-ultrathink:chain-of-verification"` ← Use this for verification
+- `subagent_type: "questionably-ultrathink:aot-recompute"` ← Use this for recomputation
+
+Calling yourself causes infinite recursion and task failure.
+\</critical\_warning\>
+
 \<clarification\_first\>
 
 ## Step 0: Clarify Intent First (MANDATORY)
@@ -72,6 +92,14 @@ After clarifying intent, use `AskUserQuestion` to determine the analysis depth:
 
 ## Available Agents
 
+**CRITICAL WARNING:** You are the orchestrator. You must NEVER invoke yourself. NEVER use `subagent_type: "questionably-ultrathink"` or `subagent_type: "questionably-ultrathink-skill"`. You can ONLY invoke these three subagents:
+
+- `questionably-ultrathink:atom-of-thoughts` - for decomposition
+- `questionably-ultrathink:chain-of-verification` - for verification
+- `questionably-ultrathink:aot-recompute` - for recomputation after corrections
+
+If you call yourself, you create infinite recursion and fail the task.
+
 ### atom-of-thoughts
 
 **Purpose:** Decompose complex problems into atomic sub-questions

package/dist/opencode/agent/aot-recompute.md

@@ -9,7 +9,6 @@ description: |-
   assistant: "I'll use the aot-recompute agent to update the dependent atoms with the correction."
   </example>
 mode: subagent
-model: anthropic/claude-3-5-haiku
 permission:
   read: allow
   write: allow

package/dist/opencode/agent/atom-of-thoughts.md

@@ -19,7 +19,6 @@ description: |-
   assistant: "I'll decompose this into atomic diagnostic questions."
   </example>
 mode: subagent
-model: anthropic/claude-3-5-haiku
 permission:
   read: allow
   grep: allow

package/dist/opencode/agent/chain-of-verification.md

@@ -18,7 +18,6 @@ description: |-
   assistant: "I'll verify this with the chain-of-verification agent."
   </example>
 mode: subagent
-model: anthropic/claude-3-5-haiku
 permission:
   read: allow
   grep: allow

package/dist/opencode/agent/questionably-ultrathink.md

@@ -1,5 +1,8 @@
 ---
 description: |-
+  CRITICAL: You ARE this agent. NEVER call subagent_type:"questionably-ultrathink" (infinite recursion).
+  ONLY use: subagent_type:"atom-of-thoughts", subagent_type:"chain-of-verification", or subagent_type:"aot-recompute".
+
   Use this skill when facing complex problems requiring rigorous reasoning, systematic decomposition, or factual verification.
 
   Activation triggers:
@@ -11,7 +14,6 @@ description: |-
   - High-stakes technical decisions
   - Debugging complex issues
 mode: primary
-model: anthropic/claude-sonnet-4-20250514
 permission:
   task: allow
   read: allow
@@ -26,6 +28,25 @@ permission:
 
 You now have access to advanced reasoning agents for rigorous analysis. Use them when problems require more than surface-level analysis.
 
+\<critical\_warning\>
+
+## ⚠️ CRITICAL: DO NOT INVOKE YOURSELF
+
+You ARE the `questionably-ultrathink` orchestrator. You must **NEVER** call:
+
+```
+subagent_type: "questionably-ultrathink"  ← FORBIDDEN (infinite recursion)
+```
+
+You can ONLY invoke these subagents:
+
+- `subagent_type: "atom-of-thoughts"` ← Use this for decomposition
+- `subagent_type: "chain-of-verification"` ← Use this for verification
+- `subagent_type: "aot-recompute"` ← Use this for recomputation
+
+Calling yourself causes infinite recursion and task failure.
+\</critical\_warning\>
+
 \<clarification\_first\>
 
 ## Step 0: Clarify Intent First (MANDATORY)
@@ -80,10 +101,18 @@ After clarifying intent, use `AskUserQuestion` to determine the analysis depth:
 
 ## Available Agents
 
+**CRITICAL WARNING:** You are `questionably-ultrathink`, the orchestrator. You must NEVER invoke yourself. NEVER use `subagent_type: "questionably-ultrathink"`. You can ONLY invoke these three subagents:
+
+- `atom-of-thoughts` - for decomposition
+- `chain-of-verification` - for verification
+- `aot-recompute` - for recomputation after corrections
+
+If you call `subagent_type: "questionably-ultrathink"`, you create infinite recursion and fail the task.
+
 ### atom-of-thoughts
 
 **Purpose:** Decompose complex problems into atomic sub-questions
-**Invoke:** `Task` tool with `@atom-of-thoughts`
+**Invoke:** `Task` tool with `subagent_type="atom-of-thoughts"`
 
 Use when:
 
@@ -95,7 +124,7 @@ Use when:
 ### chain-of-verification
 
 **Purpose:** Verify factual claims to reduce hallucinations
-**Invoke:** `Task` tool with `@chain-of-verification`
+**Invoke:** `Task` tool with `subagent_type="chain-of-verification"`
 
 Use when:
 
@@ -107,7 +136,7 @@ Use when:
 ### aot-recompute
 
 **Purpose:** Recompute atoms after CoV finds corrections
-**Invoke:** `Task` tool with `@aot-recompute`
+**Invoke:** `Task` tool with `subagent_type="aot-recompute"`
 
 Use when:
 
@@ -141,8 +170,8 @@ Example: `a1b2c3d4`
 
 **Step 2: Decompose with AoT**
 
-    Use the task tool to invoke the subagent:
-    - @atom-of-thoughts
+    Use the Task tool to invoke the subagent:
+    - subagent_type: "atom-of-thoughts"
     - prompt: "Session ID: {session-id}. Rigor: {rigor-level}. Decompose this query into atomic sub-questions: {clarified query}"
 
 **IMPORTANT:**
@@ -181,8 +210,9 @@ Process each level in order:
 
 For each atom requiring CoV, invoke the chain-of-verification agent:
 
-    Task: @chain-of-verification
-          prompt: "Session ID: {session-id}. Verify atom {atom-id}. Read the reasoning from .questionably-ultrathink/{session-id}/atoms/{atom-id}.md and verify both the factual claims AND the reasoning chain."
+    Task tool:
+      subagent_type: "chain-of-verification"
+      prompt: "Session ID: {session-id}. Verify atom {atom-id}. Read the reasoning from .questionably-ultrathink/{session-id}/atoms/{atom-id}.md and verify both the factual claims AND the reasoning chain."
 
 **Parallel execution:** Invoke ALL atoms at the same level in a SINGLE message with multiple Task calls. Wait for all results before proceeding to the next level.
 
@@ -203,8 +233,9 @@ When CoV finds errors, it writes correction files to `.questionably-ultrathink/{
 
 3. **Invoke aot-recompute:**
 
-       Task: @aot-recompute
-             prompt: "Session ID: {session-id}. Corrected atoms: [A1]. Atoms to recompute: [A3, FINAL]."
+       Task tool:
+         subagent_type: "aot-recompute"
+         prompt: "Session ID: {session-id}. Corrected atoms: [A1]. Atoms to recompute: [A3, FINAL]."
 
 4. **Re-verify recomputed atoms:**
    Add recomputed atoms back to the verification queue at their dependency level.
@@ -232,8 +263,8 @@ Display under "Phase 3: Synthesis".
 
 **Step 5: Final Verification (MANDATORY)**
 
-    Use the task tool to invoke the subagent:
-    - @chain-of-verification
+    Use the Task tool to invoke the subagent:
+    - subagent_type: "chain-of-verification"
     - prompt: "Verify this synthesized response: {synthesis}"
 
 **DO NOT SKIP THIS STEP.** The final response must be verified.
@@ -276,13 +307,15 @@ After Phase 4 (Final Verification), check if iteration is needed based on the us
 
 **Iteration invocation (new decomposition):**
 
-    Task: @atom-of-thoughts
-          prompt: "Session ID: {session-id}. Rigor: {rigor}. Re-analyze these problematic areas with fresh perspective: {list of issues}"
+    Task tool:
+      subagent_type: "atom-of-thoughts"
+      prompt: "Session ID: {session-id}. Rigor: {rigor}. Re-analyze these problematic areas with fresh perspective: {list of issues}"
 
 **Iteration invocation (correction-based update):**
 
-    Task: @aot-recompute
-          prompt: "Session ID: {session-id}. Corrected atoms: [...]. Atoms to recompute: [...]."
+    Task tool:
+      subagent_type: "aot-recompute"
+      prompt: "Session ID: {session-id}. Corrected atoms: [...]. Atoms to recompute: [...]."
 
 Then continue with Steps 3-5 for the new/revised atoms.
 \</iterative\_refinement\>

package/dist/opencode/command/questionably-ultrathink.md

@@ -1,26 +1,6 @@
 ---
-description: Apply full UltraThink reasoning pipeline (AoT + CoVe) to analyze the current problem with maximum rigor
+description: Apply full UltraThink reasoning pipeline (AoT + CoVe)
 ---
 Switch to the @questionably-ultrathink agent.
 
-
-# /questionably-ultrathink Command
-
-The user has requested full UltraThink analysis.
-
-**Immediately invoke the questionably-ultrathink-skill** using the Skill tool to execute the full pipeline:
-
-Use the Skill tool with:
-
-- skill: "questionably-ultrathink-skill"
-- args: "$ARGUMENTS"
-
-The skill contains the complete orchestration protocol for:
-
-1. Intent clarification (AskUserQuestion if needed)
-2. Atom of Thoughts decomposition (with complexity flagging)
-3. Parallel Chain of Verification for critical atoms (by dependency level)
-4. Synthesis and final verification
-5. Optional iterative refinement for high-stakes or low-confidence results
-
-Do not duplicate the orchestration logic here—let the skill handle it.
+User query: $ARGUMENTS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "questionably-ultrathink",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Claude Code plugin integrating Atom of Thoughts (AoT) and Chain of Verification (CoVe) reasoning frameworks",
   "type": "module",
   "bin": {
@@ -12,9 +12,7 @@
   ],
   "scripts": {
     "install": "bun scripts/install-plugin.ts",
-    "sync:opencode": "bun scripts/sync-opencode.ts",
-    "watch:opencode": "bun scripts/sync-opencode.ts --watch",
-    "build": "bun scripts/sync-opencode.ts && bun scripts/build-dist.ts",
+    "build": "bun scripts/build-dist.ts",
     "postinstall": "bun scripts/install-plugin.ts --auto"
   },
   "dependencies": {

package/scripts/build-dist.ts

@@ -3,9 +3,8 @@
  * Build script to prepare distribution files for npm publishing.
  *
  * This script:
- * 1. Runs sync-opencode.ts to generate OpenCode files
- * 2. Copies Claude Code files to dist/claude-code/
- * 3. Copies OpenCode files to dist/opencode/
+ * 1. Copies Claude Code files from claude-code/ to dist/claude-code/
+ * 2. Copies OpenCode files from opencode/ to dist/opencode/
  *
  * Run: bun scripts/build-dist.ts
  */
@@ -23,12 +22,9 @@ const DIST_DIR = join(ROOT_DIR, "dist");
 const DIST_CLAUDE_CODE = join(DIST_DIR, "claude-code");
 const DIST_OPENCODE = join(DIST_DIR, "opencode");
 
-// Source directories
-const AGENTS_DIR = join(ROOT_DIR, "agents");
-const COMMANDS_DIR = join(ROOT_DIR, "commands");
-const SKILLS_DIR = join(ROOT_DIR, "skills");
-const PLUGIN_DIR = join(ROOT_DIR, ".claude-plugin");
-const OPENCODE_DIR = join(ROOT_DIR, ".opencode");
+// Source directories (separate sources for each platform)
+const CLAUDE_CODE_DIR = join(ROOT_DIR, "claude-code");
+const OPENCODE_DIR = join(ROOT_DIR, "opencode");
 
 // ============================================================================
 // Utilities
@@ -65,55 +61,26 @@ async function cleanDist(): Promise<void> {
 
 async function buildClaudeCode(): Promise<void> {
   console.log("\nBuilding Claude Code distribution...");
-  await mkdir(DIST_CLAUDE_CODE, { recursive: true });
 
-  // Copy agents
-  if (existsSync(AGENTS_DIR)) {
-    await copyDir(AGENTS_DIR, join(DIST_CLAUDE_CODE, "agents"));
-    console.log("  ✓ agents/");
-  }
-
-  // Copy commands
-  if (existsSync(COMMANDS_DIR)) {
-    await copyDir(COMMANDS_DIR, join(DIST_CLAUDE_CODE, "commands"));
-    console.log("  ✓ commands/");
-  }
-
-  // Copy skills
-  if (existsSync(SKILLS_DIR)) {
-    await copyDir(SKILLS_DIR, join(DIST_CLAUDE_CODE, "skills"));
-    console.log("  ✓ skills/");
+  if (!existsSync(CLAUDE_CODE_DIR)) {
+    console.log("  ⚠ claude-code/ not found.");
+    return;
   }
 
-  // Copy plugin metadata
-  if (existsSync(PLUGIN_DIR)) {
-    await copyDir(PLUGIN_DIR, join(DIST_CLAUDE_CODE, ".claude-plugin"));
-    console.log("  ✓ .claude-plugin/");
-  }
+  await copyDir(CLAUDE_CODE_DIR, DIST_CLAUDE_CODE);
+  console.log("  ✓ Copied claude-code/ → dist/claude-code/");
 }
 
 async function buildOpenCode(): Promise<void> {
   console.log("\nBuilding OpenCode distribution...");
-  await mkdir(DIST_OPENCODE, { recursive: true });
 
   if (!existsSync(OPENCODE_DIR)) {
-    console.log("  ⚠ .opencode/ not found. Run sync-opencode.ts first.");
+    console.log("  ⚠ opencode/ not found.");
     return;
   }
 
-  // Copy agent files
-  const agentDir = join(OPENCODE_DIR, "agent");
-  if (existsSync(agentDir)) {
-    await copyDir(agentDir, join(DIST_OPENCODE, "agent"));
-    console.log("  ✓ agent/");
-  }
-
-  // Copy command files
-  const commandDir = join(OPENCODE_DIR, "command");
-  if (existsSync(commandDir)) {
-    await copyDir(commandDir, join(DIST_OPENCODE, "command"));
-    console.log("  ✓ command/");
-  }
+  await copyDir(OPENCODE_DIR, DIST_OPENCODE);
+  console.log("  ✓ Copied opencode/ → dist/opencode/");
 }
 
 // ============================================================================

package/scripts/check-frontmatter.py

@@ -62,19 +62,29 @@ def validate_command_frontmatter(
     return errors
 
 
+def is_opencode_path(file_path: Path) -> bool:
+    """Check if the file path is in the OpenCode directory structure."""
+    return "opencode" in file_path.parts
+
+
 def validate_agent_frontmatter(
     frontmatter: dict[str, Any], file_path: Path
 ) -> list[str]:
-    """Validate agent file frontmatter."""
+    """Validate agent file frontmatter.
+
+    Claude Code agents require: name, description
+    OpenCode agents require: description (name is optional, uses filename)
+    """
     errors = []
 
-    # Agents should have name and description
-    if "name" not in frontmatter:
-        errors.append("Missing required field 'name'")
-    elif (
-        not isinstance(frontmatter["name"], str) or not frontmatter["name"].strip()
-    ):
-        errors.append("Field 'name' must be a non-empty string")
+    # OpenCode agents don't require name - they use the filename
+    if not is_opencode_path(file_path):
+        if "name" not in frontmatter:
+            errors.append("Missing required field 'name'")
+        elif (
+            not isinstance(frontmatter["name"], str) or not frontmatter["name"].strip()
+        ):
+            errors.append("Field 'name' must be a non-empty string")
 
     if "description" not in frontmatter:
         errors.append("Missing required field 'description'")
@@ -88,14 +98,19 @@ def validate_agent_frontmatter(
 
 
 def get_file_type(file_path: Path) -> str | None:
-    """Determine the type of file based on its directory."""
+    """Determine the type of file based on its directory.
+
+    Handles both Claude Code and OpenCode directory structures:
+    - Claude Code: commands/, skills/, agents/
+    - OpenCode: command/, agent/
+    """
     parts = file_path.parts
     for i, part in enumerate(parts):
         if part == "skills":
             return "skill"
-        elif part == "commands":
+        elif part in ("commands", "command"):
             return "command"
-        elif part == "agents":
+        elif part in ("agents", "agent"):
             return "agent"
     return None
 

package/scripts/install-plugin.ts

@@ -17,7 +17,7 @@
  *   OpenCode: ~/.config/opencode/
  */
 
-import { copyFile, readdir, mkdir, stat } from "fs/promises";
+import { copyFile, readdir, mkdir, stat, rm } from "fs/promises";
 import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -35,9 +35,9 @@ const ROOT_DIR = join(SCRIPT_DIR, "..");
 const DIST_DIR = join(ROOT_DIR, "dist");
 const USE_DIST = existsSync(DIST_DIR);
 
-// Source paths (development)
-const DEV_CLAUDE_CODE = ROOT_DIR;
-const DEV_OPENCODE = join(ROOT_DIR, ".opencode");
+// Source paths (development) - separate directories for each platform
+const DEV_CLAUDE_CODE = join(ROOT_DIR, "claude-code");
+const DEV_OPENCODE = join(ROOT_DIR, "opencode");
 
 // Dist paths (installed)
 const DIST_CLAUDE_CODE = join(DIST_DIR, "claude-code");
@@ -48,7 +48,7 @@ const CLAUDE_CODE_PLUGINS_DIR = join(
   homedir(),
   ".claude",
   "plugins",
-  "questionably-ultrathink"
+  "questionably-ultrathink",
 );
 const OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode");
 
@@ -109,26 +109,6 @@ function getDetectedList(detected: DetectionResult): Platform[] {
   return platforms;
 }
 
-// ============================================================================
-// OpenCode Sync (imports sync logic if needed in development)
-// ============================================================================
-
-async function syncOpenCode(): Promise<boolean> {
-  // Only needed in development mode when .opencode doesn't exist
-  if (USE_DIST) return true;
-
-  if (!existsSync(DEV_OPENCODE)) {
-    // Run the sync script
-    const proc = Bun.spawn(["bun", join(SCRIPT_DIR, "sync-opencode.ts")], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    await proc.exited;
-    return proc.exitCode === 0;
-  }
-  return true;
-}
-
 // ============================================================================
 // Installation Functions
 // ============================================================================
@@ -141,6 +121,10 @@ async function installClaudeCode(): Promise<boolean> {
   }
 
   try {
+    // Clean existing installation for a fresh update
+    if (existsSync(CLAUDE_CODE_PLUGINS_DIR)) {
+      await rm(CLAUDE_CODE_PLUGINS_DIR, { recursive: true });
+    }
     await mkdir(CLAUDE_CODE_PLUGINS_DIR, { recursive: true });
 
     // Copy agents
@@ -164,10 +148,7 @@ async function installClaudeCode(): Promise<boolean> {
     // Copy plugin metadata
     const pluginDir = join(sourceDir, ".claude-plugin");
     if (existsSync(pluginDir)) {
-      await copyDir(
-        pluginDir,
-        join(CLAUDE_CODE_PLUGINS_DIR, ".claude-plugin")
-      );
+      await copyDir(pluginDir, join(CLAUDE_CODE_PLUGINS_DIR, ".claude-plugin"));
     }
 
     return true;
@@ -186,7 +167,7 @@ async function installOpenCode(): Promise<boolean> {
   try {
     await mkdir(OPENCODE_CONFIG_DIR, { recursive: true });
 
-    // Copy agent files
+    // Copy agent files (delete existing first for clean update)
     const agentDir = join(sourceDir, "agent");
     if (existsSync(agentDir)) {
       const destAgentDir = join(OPENCODE_CONFIG_DIR, "agent");
@@ -195,12 +176,17 @@ async function installOpenCode(): Promise<boolean> {
       const files = await readdir(agentDir);
       for (const file of files) {
         if (file.endsWith(".md")) {
-          await copyFile(join(agentDir, file), join(destAgentDir, file));
+          const destPath = join(destAgentDir, file);
+          // Remove existing file first for clean update
+          if (existsSync(destPath)) {
+            await rm(destPath);
+          }
+          await copyFile(join(agentDir, file), destPath);
         }
       }
     }
 
-    // Copy command files
+    // Copy command files (delete existing first for clean update)
     const commandDir = join(sourceDir, "command");
     if (existsSync(commandDir)) {
       const destCommandDir = join(OPENCODE_CONFIG_DIR, "command");
@@ -209,7 +195,12 @@ async function installOpenCode(): Promise<boolean> {
       const files = await readdir(commandDir);
       for (const file of files) {
         if (file.endsWith(".md")) {
-          await copyFile(join(commandDir, file), join(destCommandDir, file));
+          const destPath = join(destCommandDir, file);
+          // Remove existing file first for clean update
+          if (existsSync(destPath)) {
+            await rm(destPath);
+          }
+          await copyFile(join(commandDir, file), destPath);
         }
       }
     }
@@ -258,7 +249,8 @@ async function runInteractive(): Promise<void> {
         hint: "~/.config/opencode/",
       },
     ],
-    initialValues: detectedList.length > 0 ? detectedList : ["claude-code", "opencode"],
+    initialValues:
+      detectedList.length > 0 ? detectedList : ["claude-code", "opencode"],
     required: true,
   });
 
@@ -273,34 +265,27 @@ async function runInteractive(): Promise<void> {
 
 async function runNonInteractive(
   installClaudeCodeFlag: boolean,
-  installOpenCodeFlag: boolean
+  installOpenCodeFlag: boolean,
 ): Promise<void> {
   console.log("UltraThink Plugin Installer");
   console.log("===========================");
-  console.log(`Source: ${USE_DIST ? "dist/ (installed)" : "local (development)"}`);
+  console.log(
+    `Source: ${USE_DIST ? "dist/ (installed)" : "local (development)"}`,
+  );
 
   const platforms: Platform[] = [];
   if (installClaudeCodeFlag) platforms.push("claude-code");
   if (installOpenCodeFlag) platforms.push("opencode");
 
   if (platforms.length === 0) {
-    console.log("\nNo platforms specified. Use --claude-code, --opencode, or --both.");
+    console.log(
+      "\nNo platforms specified. Use --claude-code, --opencode, or --both.",
+    );
     process.exit(1);
   }
 
   console.log("\nInstalling to:", platforms.join(", "));
 
-  // Sync OpenCode if needed
-  if (platforms.includes("opencode") && !USE_DIST) {
-    console.log("\nSyncing OpenCode files...");
-    const synced = await syncOpenCode();
-    if (!synced) {
-      console.log("  ⚠ Failed to sync OpenCode files");
-    } else {
-      console.log("  ✓ Synced OpenCode files");
-    }
-  }
-
   let success = true;
 
   if (platforms.includes("claude-code")) {
@@ -342,16 +327,6 @@ async function performInstallation(platforms: Platform[]): Promise<void> {
 
   const results: string[] = [];
 
-  // Sync OpenCode if needed
-  if (platforms.includes("opencode") && !USE_DIST) {
-    const synced = await syncOpenCode();
-    if (synced) {
-      results.push("✓ Synced OpenCode files");
-    } else {
-      results.push("⚠ Failed to sync OpenCode files");
-    }
-  }
-
   // Install to Claude Code
   if (platforms.includes("claude-code")) {
     const success = await installClaudeCode();
@@ -449,7 +424,7 @@ async function main(): Promise<void> {
   if (hasClaudeCodeFlag || hasOpenCodeFlag || hasBothFlag) {
     await runNonInteractive(
       hasClaudeCodeFlag || hasBothFlag,
-      hasOpenCodeFlag || hasBothFlag
+      hasOpenCodeFlag || hasBothFlag,
     );
     return;
   }
@@ -469,7 +444,7 @@ async function main(): Promise<void> {
 
     await runNonInteractive(
       platforms.includes("claude-code"),
-      platforms.includes("opencode")
+      platforms.includes("opencode"),
     );
     return;
   }

package/scripts/validate-plugin.sh

@@ -106,7 +106,31 @@ validate_directory_structure() {
 
     local has_content=false
 
-    # Check for required content directories
+    # Check Claude Code directories (claude-code/commands/, claude-code/skills/, claude-code/agents/)
+    for dir in "claude-code/commands" "claude-code/skills" "claude-code/agents"; do
+        if [[ -d "$dir" ]]; then
+            local md_count
+            md_count=$(find "$dir" -name "*.md" | wc -l)
+            if [[ $md_count -gt 0 ]]; then
+                has_content=true
+                echo "  Found $md_count .md file(s) in $dir/"
+            fi
+        fi
+    done
+
+    # Check OpenCode directories (opencode/command/, opencode/agent/)
+    for dir in "opencode/command" "opencode/agent"; do
+        if [[ -d "$dir" ]]; then
+            local md_count
+            md_count=$(find "$dir" -name "*.md" | wc -l)
+            if [[ $md_count -gt 0 ]]; then
+                has_content=true
+                echo "  Found $md_count .md file(s) in $dir/"
+            fi
+        fi
+    done
+
+    # Fallback: check legacy root directories (commands/, skills/, agents/)
     for dir in "commands" "skills" "agents"; do
         if [[ -d "$dir" ]]; then
             local md_count
@@ -119,7 +143,7 @@ validate_directory_structure() {
     done
 
     if [[ "$has_content" == "false" ]]; then
-        error "Plugin must have at least one of: commands/, skills/, or agents/ with .md files"
+        error "Plugin must have at least one of: commands/, skills/, agents/, claude-code/*/, or opencode/*/ with .md files"
         exit 1
     fi
 

package/dist/claude-code/.claude-plugin/marketplace.json

@@ -1,17 +0,0 @@
-{
-  "name": "questionably-ultrathink",
-  "owner": {
-    "name": "snowmead"
-  },
-  "metadata": {
-    "description": "Plugin marketplace for UltraThink reasoning framework integrating Chain of Verification and Atom of Thoughts",
-    "version": "1.0.0"
-  },
-  "plugins": [
-    {
-      "name": "questionably-ultrathink",
-      "description": "Advanced reasoning plugin integrating Chain of Verification (CoVe) and Atom of Thoughts (AoT) frameworks for rigorous, verifiable analysis",
-      "source": "./"
-    }
-  ]
-}

package/scripts/sync-opencode.ts

@@ -1,349 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Sync script to translate Claude Code plugin files to OpenCode format.
- *
- * This script maintains Claude Code as the source of truth and generates
- * OpenCode-compatible files in .opencode/
- *
- * Run: bun scripts/sync-opencode.ts
- * Watch: bun scripts/sync-opencode.ts --watch
- */
-
-import { readdir, readFile, writeFile, mkdir, rm } from "fs/promises";
-import { existsSync } from "fs";
-import { join, basename } from "path";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-
-// ============================================================================
-// Types
-// ============================================================================
-
-interface ClaudeCodeAgentFrontmatter {
-  name: string;
-  description: string;
-  model?: string;
-  tools?: string[];
-}
-
-interface ClaudeCodeCommandFrontmatter {
-  name: string;
-  description: string;
-  "allowed-tools"?: string[];
-}
-
-interface ClaudeCodeSkillFrontmatter {
-  name: string;
-  description: string;
-  "allowed-tools"?: string[];
-}
-
-interface OpenCodeAgentFrontmatter {
-  description: string;
-  mode: "primary" | "subagent";
-  model?: string;
-  permission?: Record<string, "allow" | "ask" | "deny">;
-  hidden?: boolean;
-}
-
-interface OpenCodeCommandFrontmatter {
-  description: string;
-}
-
-interface ParsedFile<T> {
-  frontmatter: T;
-  body: string;
-}
-
-// ============================================================================
-// Configuration
-// ============================================================================
-
-const ROOT_DIR = process.cwd();
-const AGENTS_DIR = join(ROOT_DIR, "agents");
-const COMMANDS_DIR = join(ROOT_DIR, "commands");
-const SKILLS_DIR = join(ROOT_DIR, "skills");
-const OPENCODE_AGENT_DIR = join(ROOT_DIR, ".opencode", "agent");
-const OPENCODE_COMMAND_DIR = join(ROOT_DIR, ".opencode", "command");
-
-// Model mapping from Claude Code shorthand to OpenCode full IDs
-const MODEL_MAP: Record<string, string> = {
-  haiku: "anthropic/claude-3-5-haiku",
-  sonnet: "anthropic/claude-sonnet-4-20250514",
-  opus: "anthropic/claude-opus-4-20250514",
-};
-
-// Tool name mapping from Claude Code to OpenCode permission names
-const TOOL_MAP: Record<string, string> = {
-  Read: "read",
-  Write: "write",
-  Edit: "edit",
-  Bash: "bash",
-  Grep: "grep",
-  Glob: "glob",
-  WebFetch: "webfetch",
-  WebSearch: "webfetch",
-  AskUserQuestion: "ask",
-  Task: "task",
-};
-
-// ============================================================================
-// Utilities
-// ============================================================================
-
-/**
- * Parse a markdown file with YAML frontmatter
- */
-function parseFrontmatter<T>(content: string): ParsedFile<T> {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match) {
-    throw new Error("Invalid frontmatter format");
-  }
-  return {
-    frontmatter: parseYaml(match[1]) as T,
-    body: match[2],
-  };
-}
-
-/**
- * Format a file with YAML frontmatter
- */
-function formatWithFrontmatter<T>(frontmatter: T, body: string): string {
-  const yamlContent = stringifyYaml(frontmatter, { lineWidth: 0 });
-  return `---\n${yamlContent}---\n${body}`;
-}
-
-/**
- * Translate Claude Code model name to OpenCode model ID
- */
-function translateModel(model?: string): string | undefined {
-  if (!model) return undefined;
-  return MODEL_MAP[model] || model;
-}
-
-/**
- * Translate Claude Code tools array to OpenCode permission object
- */
-function translateTools(
-  tools?: string[]
-): Record<string, "allow"> | undefined {
-  if (!tools || tools.length === 0) return undefined;
-
-  const result: Record<string, "allow"> = {};
-  for (const tool of tools) {
-    // Handle MCP tool patterns (e.g., mcp__parallel-search__*)
-    if (tool.startsWith("mcp__")) {
-      result["mcp"] = "allow";
-      continue;
-    }
-    const mapped = TOOL_MAP[tool];
-    if (mapped) {
-      result[mapped] = "allow";
-    }
-  }
-  return Object.keys(result).length > 0 ? result : undefined;
-}
-
-/**
- * Translate body content from Claude Code patterns to OpenCode patterns
- */
-function translateBody(body: string): string {
-  return (
-    body
-      // Translate subagent_type references in Task tool invocations
-      .replace(
-        /subagent_type:\s*["']questionably-ultrathink:([^"']+)["']/g,
-        "@$1"
-      )
-      // Also handle unquoted variants
-      .replace(/subagent_type:\s*questionably-ultrathink:(\S+)/g, "@$1")
-      // Translate "Invoke Task tool" phrases
-      .replace(
-        /Invoke (?:the )?Task tool/gi,
-        "Use the task tool to invoke the subagent"
-      )
-      // Translate "Task tool" in code blocks
-      .replace(/Task tool:\s*\n/g, "Task:\n")
-  );
-}
-
-/**
- * Clean the output directories
- */
-async function cleanOutputDirs(): Promise<void> {
-  if (existsSync(OPENCODE_AGENT_DIR)) {
-    await rm(OPENCODE_AGENT_DIR, { recursive: true });
-  }
-  if (existsSync(OPENCODE_COMMAND_DIR)) {
-    await rm(OPENCODE_COMMAND_DIR, { recursive: true });
-  }
-}
-
-// ============================================================================
-// Sync Functions
-// ============================================================================
-
-/**
- * Sync agents from agents/ to .opencode/agent/
- */
-async function syncAgents(): Promise<void> {
-  console.log("Syncing agents...");
-  await mkdir(OPENCODE_AGENT_DIR, { recursive: true });
-
-  const files = await readdir(AGENTS_DIR);
-  const mdFiles = files.filter((f) => f.endsWith(".md"));
-
-  for (const file of mdFiles) {
-    const content = await readFile(join(AGENTS_DIR, file), "utf-8");
-    const { frontmatter, body } =
-      parseFrontmatter<ClaudeCodeAgentFrontmatter>(content);
-
-    const openCodeFrontmatter: OpenCodeAgentFrontmatter = {
-      description: frontmatter.description.trim(),
-      mode: "subagent",
-      model: translateModel(frontmatter.model),
-      permission: translateTools(frontmatter.tools),
-      hidden: true, // Hide subagents from @ menu
-    };
-
-    // Remove undefined fields
-    if (!openCodeFrontmatter.model) delete openCodeFrontmatter.model;
-    if (!openCodeFrontmatter.permission) delete openCodeFrontmatter.permission;
-
-    const translatedBody = translateBody(body);
-    const outputContent = formatWithFrontmatter(
-      openCodeFrontmatter,
-      translatedBody
-    );
-
-    await writeFile(join(OPENCODE_AGENT_DIR, file), outputContent);
-    console.log(`  ✓ ${file}`);
-  }
-}
-
-/**
- * Sync the skill as the primary orchestrator agent
- */
-async function syncSkill(): Promise<void> {
-  console.log("Syncing skill as orchestrator...");
-
-  const skillDir = join(SKILLS_DIR, "questionably-ultrathink-skill");
-  const skillPath = join(skillDir, "SKILL.md");
-
-  if (!existsSync(skillPath)) {
-    console.log("  ⚠ No skill found, skipping orchestrator");
-    return;
-  }
-
-  const content = await readFile(skillPath, "utf-8");
-  const { frontmatter, body } =
-    parseFrontmatter<ClaudeCodeSkillFrontmatter>(content);
-
-  // Build permission with task subagent permissions
-  const basePermissions = translateTools(frontmatter["allowed-tools"]) || {};
-
-  const openCodeFrontmatter: OpenCodeAgentFrontmatter = {
-    description: frontmatter.description.trim(),
-    mode: "primary",
-    model: "anthropic/claude-sonnet-4-20250514",
-    permission: {
-      ...basePermissions,
-      task: "allow", // Allow invoking subagents
-    },
-  };
-
-  const translatedBody = translateBody(body);
-  const outputContent = formatWithFrontmatter(
-    openCodeFrontmatter,
-    translatedBody
-  );
-
-  await mkdir(OPENCODE_AGENT_DIR, { recursive: true });
-  await writeFile(
-    join(OPENCODE_AGENT_DIR, "questionably-ultrathink.md"),
-    outputContent
-  );
-  console.log("  ✓ questionably-ultrathink.md (orchestrator)");
-}
-
-/**
- * Sync commands from commands/ to .opencode/command/
- */
-async function syncCommands(): Promise<void> {
-  console.log("Syncing commands...");
-  await mkdir(OPENCODE_COMMAND_DIR, { recursive: true });
-
-  const files = await readdir(COMMANDS_DIR);
-  const mdFiles = files.filter((f) => f.endsWith(".md"));
-
-  for (const file of mdFiles) {
-    const content = await readFile(join(COMMANDS_DIR, file), "utf-8");
-    const { frontmatter, body } =
-      parseFrontmatter<ClaudeCodeCommandFrontmatter>(content);
-
-    const openCodeFrontmatter: OpenCodeCommandFrontmatter = {
-      description: frontmatter.description,
-    };
-
-    // Translate body and add agent switch directive for skill-invoking commands
-    let translatedBody = translateBody(body);
-
-    // If the command invokes the Skill tool, add switch directive
-    if (body.includes("Skill tool") || body.includes("skill:")) {
-      translatedBody = `Switch to the @questionably-ultrathink agent.\n\n${translatedBody}`;
-    }
-
-    const outputContent = formatWithFrontmatter(
-      openCodeFrontmatter,
-      translatedBody
-    );
-
-    await writeFile(join(OPENCODE_COMMAND_DIR, file), outputContent);
-    console.log(`  ✓ ${file}`);
-  }
-}
-
-// ============================================================================
-// Main
-// ============================================================================
-
-async function main(): Promise<void> {
-  const isWatch = process.argv.includes("--watch");
-
-  console.log("OpenCode Sync Script");
-  console.log("====================\n");
-
-  if (isWatch) {
-    console.log("Watch mode not yet implemented. Running single sync.\n");
-  }
-
-  try {
-    // Clean output directories
-    console.log("Cleaning output directories...");
-    await cleanOutputDirs();
-    console.log("  ✓ Done\n");
-
-    // Sync all components
-    await syncAgents();
-    console.log("");
-    await syncSkill();
-    console.log("");
-    await syncCommands();
-
-    console.log("\n✅ Sync complete!");
-    console.log("\nGenerated files:");
-    console.log("  .opencode/agent/");
-    console.log("    - atom-of-thoughts.md");
-    console.log("    - chain-of-verification.md");
-    console.log("    - aot-recompute.md");
-    console.log("    - questionably-ultrathink.md (orchestrator)");
-    console.log("  .opencode/command/");
-    console.log("    - questionably-ultrathink.md");
-    console.log("    - decompose.md");
-    console.log("    - verify.md");
-  } catch (error) {
-    console.error("\n❌ Sync failed:", error);
-    process.exit(1);
-  }
-}
-
-main();