@withakay/opencode-autopilot 0.3.0 → 0.3.2

package/.opencode/agents/Autopilot-Wingman-GH-GPT54.md

@@ -0,0 +1,25 @@
+---
+description: Deep reasoning Wingman for architecture, planning, and complex delegated work
+mode: all
+model: github-copilot/gpt-5.4
+tools:
+  bash: true
+  read: true
+  glob: true
+  grep: true
+  edit: true
+  write: true
+  apply_patch: true
+---
+
+You are Autopilot-Wingman-GH-GPT54, a high-capability reasoning wingman used by the OpenCode autopilot plugin.
+
+Your job is to handle complex delegated work such as architectural changes, difficult debugging, and planning-heavy implementation.
+
+Operating rules:
+- Break complex work into concrete steps.
+- Prefer robust solutions over quick hacks.
+- Validate the most important risks before concluding.
+- Keep outputs grounded in observable repo facts.
+
+When the task is done, summarize the solution and validation.

package/.opencode/agents/Autopilot-Wingman-GH-Gemini31.md

@@ -0,0 +1,25 @@
+---
+description: Large-context Wingman for documentation, synthesis, and broad delegated work
+mode: all
+model: github-copilot/gemini-3.1-pro-preview
+tools:
+  bash: true
+  read: true
+  glob: true
+  grep: true
+  edit: true
+  write: true
+  apply_patch: true
+---
+
+You are Autopilot-Wingman-GH-Gemini31, a large-context wingman used by the OpenCode autopilot plugin.
+
+Your job is to handle delegated work that benefits from reading broadly across a project, synthesizing information, and producing coherent results.
+
+Operating rules:
+- Gather enough context before editing.
+- Keep summaries structured and easy to scan.
+- Prefer maintainable documentation and clear reasoning.
+- Validate outputs against the stated task.
+
+When the task is done, summarize the result and checks performed.

package/.opencode/agents/Autopilot-Wingman-GH-Sonnet46.md

@@ -0,0 +1,25 @@
+---
+description: Careful review and validation Wingman for autopilot delegated work
+mode: all
+model: github-copilot/claude-sonnet-4.6
+tools:
+  bash: true
+  read: true
+  glob: true
+  grep: true
+  edit: true
+  write: true
+  apply_patch: true
+---
+
+You are Autopilot-Wingman-GH-Sonnet46, a careful validation-oriented wingman used by the OpenCode autopilot plugin.
+
+Your job is to perform high-signal delegated work with a bias toward correctness, validation, and careful reasoning.
+
+Operating rules:
+- Be skeptical of unverified claims.
+- Check file contents, command output, and task requirements directly.
+- Prefer safer changes when uncertainty exists.
+- Call out remaining risks explicitly if any exist.
+
+When the task is done, summarize what was done and what was verified.

package/.opencode/agents/Autopilot-Wingman-GLM51.md

@@ -0,0 +1,26 @@
+---
+description: Fast general-purpose Wingman for autopilot delegated work
+mode: all
+model: chutes/zai-org/GLM-5.1-TEE
+tools:
+  bash: true
+  read: true
+  glob: true
+  grep: true
+  edit: true
+  write: true
+  apply_patch: true
+---
+
+You are Autopilot-Wingman-GLM51, a fast general-purpose wingman used by the OpenCode autopilot plugin.
+
+Your job is to execute delegated tasks efficiently while staying reliable.
+
+Operating rules:
+- Prefer small, safe, reversible changes.
+- Read before editing.
+- Validate changes whenever practical.
+- If asked to review or validate, be strict and evidence-based.
+- If asked to implement, make forward progress without unnecessary questions.
+
+When the task is done, summarize what you changed and any validation you performed.

package/.opencode/agents/Autopilot-Wingman-Kimi25.md

@@ -0,0 +1,25 @@
+---
+description: Strong coding and reasoning Wingman for autopilot delegated work
+mode: all
+model: chutes/moonshotai/Kimi-K2.5-TEE
+tools:
+  bash: true
+  read: true
+  glob: true
+  grep: true
+  edit: true
+  write: true
+  apply_patch: true
+---
+
+You are Autopilot-Wingman-Kimi25, a coding-focused wingman used by the OpenCode autopilot plugin.
+
+Your job is to handle implementation-heavy tasks, refactors, debugging, and multi-step code changes.
+
+Operating rules:
+- Preserve existing patterns unless there is a clear reason to improve them.
+- Prefer concrete evidence over assumptions.
+- Run relevant checks after changing code.
+- Keep responses concise and action-oriented.
+
+When the task is done, summarize the result and validation.

package/.opencode/agents/Autopilot-Wingman-MiniMax25.md

@@ -0,0 +1,25 @@
+---
+description: Balanced Wingman for testing, documentation, and general delegated work
+mode: all
+model: chutes/MiniMaxAI/MiniMax-M2.5-TEE
+tools:
+  bash: true
+  read: true
+  glob: true
+  grep: true
+  edit: true
+  write: true
+  apply_patch: true
+---
+
+You are Autopilot-Wingman-MiniMax25, a balanced wingman used by the OpenCode autopilot plugin.
+
+Your job is to perform solid, dependable delegated work across implementation, test, and documentation tasks.
+
+Operating rules:
+- Be methodical.
+- Prefer clarity over cleverness.
+- Validate what you can.
+- Leave the workspace better than you found it.
+
+When the task is done, summarize the work and any checks performed.

package/.opencode/commands/autopilot.md

@@ -0,0 +1,20 @@
+---
+description: Control session autopilot or hand off a long-running task
+---
+Use the `autopilot` tool to control session autopilot.
+
+Interpret `$ARGUMENTS` like this:
+- `on` => enable autopilot for the rest of the session
+- `off` or `stop` => disable autopilot
+- `status` => show autopilot status
+- `help` => show autopilot usage
+- anything else => treat it as the delegated task and start it immediately
+
+Additional parsing rules:
+- If the user includes `allow-all` or `allow all`, set `permissionMode` to `allow-all`
+- If the user includes `limited`, set `permissionMode` to `limited`
+- If the user includes a continuation cap such as `max 3`, `max=3`, or `continue 3 times`, pass it as `maxContinues`
+- If the user includes `agent <name>`, `use <name>`, or `agent=<name>`, pass it as `workerAgent`
+- If the user includes `conservative`, `balanced`, or `aggressive`, pass it as `autonomousStrength`
+
+Return only the tool result.

package/.opencode/wingman-config.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "./wingman-config.schema.json",
+  "description": "Autopilot Wingman Configuration - Define subagents with specific models",
+  "wingmen": {
+    "Autopilot-Wingman-GLM51": {
+      "description": "Fast, efficient general-purpose assistant",
+      "model": {
+        "provider": "chutes",
+        "model": "chutes/zai-org/GLM-5.1-TEE"
+      },
+      "strength": "balanced",
+      "roles": ["general", "quick-tasks", "drafting"]
+    },
+    "Autopilot-Wingman-Kimi25": {
+      "description": "Strong reasoning and coding capabilities",
+      "model": {
+        "provider": "chutes",
+        "model": "chutes/moonshotai/Kimi-K2.5-TEE"
+      },
+      "strength": "aggressive",
+      "roles": ["coding", "analysis", "refactoring"]
+    },
+    "Autopilot-Wingman-MiniMax25": {
+      "description": "Balanced performance for most tasks",
+      "model": {
+        "provider": "chutes",
+        "model": "chutes/MiniMaxAI/MiniMax-M2.5-TEE"
+      },
+      "strength": "balanced",
+      "roles": ["general", "testing", "documentation"]
+    },
+    "Autopilot-Wingman-GH-GPT54": {
+      "description": "Latest GPT model via GitHub Copilot",
+      "model": {
+        "provider": "github-copilot",
+        "model": "github-copilot/gpt-5.4"
+      },
+      "strength": "balanced",
+      "roles": ["complex-reasoning", "architecture", "planning"]
+    },
+    "Autopilot-Wingman-GH-Gemini31": {
+      "description": "Google Gemini Pro for multimodal tasks",
+      "model": {
+        "provider": "github-copilot",
+        "model": "github-copilot/gemini-3.1-pro-preview"
+      },
+      "strength": "aggressive",
+      "roles": ["large-context", "documentation", "research"]
+    },
+    "Autopilot-Wingman-GH-Sonnet46": {
+      "description": "Claude Sonnet for careful, thorough work",
+      "model": {
+        "provider": "github-copilot",
+        "model": "github-copilot/claude-sonnet-4.6"
+      },
+      "strength": "conservative",
+      "roles": ["code-review", "validation", "safety-critical"]
+    }
+  },
+  "routing": {
+    "default": "Autopilot-Wingman-Kimi25",
+    "rules": [
+      {
+        "taskPattern": "test|spec|validate",
+        "wingman": "Autopilot-Wingman-GH-Sonnet46"
+      },
+      {
+        "taskPattern": "refactor|clean|simplify",
+        "wingman": "Autopilot-Wingman-Kimi25"
+      },
+      {
+        "taskPattern": "document|readme|explain",
+        "wingman": "Autopilot-Wingman-GH-Gemini31"
+      },
+      {
+        "taskPattern": "quick|simple|draft",
+        "wingman": "Autopilot-Wingman-GLM51"
+      },
+      {
+        "taskPattern": "design|architecture|plan",
+        "wingman": "Autopilot-Wingman-GH-GPT54"
+      }
+    ]
+  }
+}

package/README.md

@@ -10,6 +10,27 @@ npm install @withakay/opencode-autopilot
 bun add @withakay/opencode-autopilot
 ```
 
+### What gets installed for end users
+
+On install, the package runs a postinstall script that provisions OpenCode assets into the consuming project:
+
+- `.opencode/commands/autopilot.md` — the `/autopilot` slash command
+- `.opencode/agents/Autopilot-Wingman-GLM51.md`
+- `.opencode/agents/Autopilot-Wingman-Kimi25.md`
+- `.opencode/agents/Autopilot-Wingman-MiniMax25.md`
+- `.opencode/agents/Autopilot-Wingman-GH-GPT54.md`
+- `.opencode/agents/Autopilot-Wingman-GH-Gemini31.md`
+- `.opencode/agents/Autopilot-Wingman-GH-Sonnet46.md`
+- `.opencode/wingman-config.json` — routing/reference config for the packaged Wingman presets
+
+The installer is non-destructive for Wingman assets:
+
+- existing Wingman agent files are preserved if you have customized them
+- existing `wingman-config.json` is preserved if you have customized it
+- the `/autopilot` slash command is updated to the packaged version when it changes
+
+This package does **not** dynamically register slash commands or agents through the plugin API. Instead, it installs the corresponding OpenCode markdown assets into your project so they are available to end users immediately.
+
 ## Usage
 
 Register the plugin in your `opencode.jsonc`:
@@ -37,6 +58,25 @@ After registering the plugin, the primary UX is:
 - **`/autopilot status`** — inspect current state
 - **`/autopilot <task>`** — enable autopilot and delegate a long-running task immediately
 
+### Packaged Wingman agents
+
+The package also installs a set of reusable Wingman agents in `.opencode/agents/` for delegated work. These can be referenced by name when you want autopilot to use a specific worker agent.
+
+Available packaged agents:
+
+- `Autopilot-Wingman-GLM51`
+- `Autopilot-Wingman-Kimi25`
+- `Autopilot-Wingman-MiniMax25`
+- `Autopilot-Wingman-GH-GPT54`
+- `Autopilot-Wingman-GH-Gemini31`
+- `Autopilot-Wingman-GH-Sonnet46`
+
+Example direct tool usage with a packaged Wingman:
+
+- `autopilot(task="Fix the failing tests", workerAgent="Autopilot-Wingman-GH-Sonnet46")`
+- `autopilot(task="Refactor the reducer logic", workerAgent="Autopilot-Wingman-Kimi25")`
+- `autopilot(task="Summarize the architecture", workerAgent="Autopilot-Wingman-GH-Gemini31")`
+
 If you prefer to call the tool directly, use:
 
 ```jsonc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withakay/opencode-autopilot",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Autopilot mode plugin for OpenCode - autonomous multi-step task execution with safety guarantees",
   "type": "module",
   "main": "./dist/index.js",
@@ -14,7 +14,11 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    ".opencode/commands/autopilot.md",
+    ".opencode/agents/*.md",
+    ".opencode/wingman-config.json",
+    "scripts/install-slash-command.mjs"
   ],
   "scripts": {
     "build": "bun build ./index.ts --outdir ./dist --target node --sourcemap --external @opencode-ai/plugin --external @opencode-ai/sdk",
@@ -23,7 +27,8 @@
     "lint": "biome check .",
     "format": "biome format . --write",
     "check": "bun run lint && bun run typecheck",
-    "prepublishOnly": "bun run build"
+    "prepublishOnly": "bun run build",
+    "postinstall": "node scripts/install-slash-command.mjs"
   },
   "keywords": [
     "opencode",

package/scripts/install-slash-command.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readdir, readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function findProjectRoot() {
+  let projectRoot = process.cwd();
+
+  for (let i = 0; i < 10; i += 1) {
+    if (existsSync(join(projectRoot, "package.json"))) {
+      return projectRoot;
+    }
+
+    const parent = dirname(projectRoot);
+    if (parent === projectRoot) {
+      break;
+    }
+    projectRoot = parent;
+  }
+
+  return null;
+}
+
+async function copyManagedFile(sourceFile, targetFile, options = {}) {
+  const { updateIfDifferent = true, label = targetFile } = options;
+
+  if (!existsSync(sourceFile)) {
+    console.log(`⚠️  Missing packaged asset: ${sourceFile}`);
+    return false;
+  }
+
+  await mkdir(dirname(targetFile), { recursive: true });
+
+  if (existsSync(targetFile)) {
+    const [existing, source] = await Promise.all([
+      readFile(targetFile, "utf-8"),
+      readFile(sourceFile, "utf-8"),
+    ]);
+
+    if (existing === source) {
+      console.log(`✅ ${label} already up to date`);
+      return false;
+    }
+
+    if (!updateIfDifferent) {
+      console.log(`ℹ️  Preserving existing ${label}`);
+      return false;
+    }
+
+    console.log(`📝 Updating ${label}...`);
+  } else {
+    console.log(`🚀 Installing ${label}...`);
+  }
+
+  await copyFile(sourceFile, targetFile);
+  console.log(`✅ Installed ${label} to: ${targetFile}`);
+  return true;
+}
+
+async function installAssets() {
+  try {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot) {
+      console.log("⚠️  Could not find project root (no package.json found)");
+      console.log("   Skipping OpenCode asset installation");
+      return;
+    }
+
+    const packageOpencodeRoot = resolve(__dirname, "..", ".opencode");
+    const projectOpencodeRoot = join(projectRoot, ".opencode");
+
+    const slashCommandSource = join(packageOpencodeRoot, "commands", "autopilot.md");
+    const slashCommandTarget = join(projectOpencodeRoot, "commands", "autopilot.md");
+
+    await copyManagedFile(slashCommandSource, slashCommandTarget, {
+      updateIfDifferent: true,
+      label: "autopilot slash command",
+    });
+
+    const wingmanConfigSource = join(packageOpencodeRoot, "wingman-config.json");
+    const wingmanConfigTarget = join(projectOpencodeRoot, "wingman-config.json");
+
+    await copyManagedFile(wingmanConfigSource, wingmanConfigTarget, {
+      updateIfDifferent: false,
+      label: "Wingman config",
+    });
+
+    const packagedAgentsDir = join(packageOpencodeRoot, "agents");
+    if (!existsSync(packagedAgentsDir)) {
+      console.log("⚠️  No packaged Wingman agents directory found");
+      return;
+    }
+
+    const agentFiles = (await readdir(packagedAgentsDir)).filter((name) => name.endsWith(".md"));
+    const projectAgentsDir = join(projectOpencodeRoot, "agents");
+    await mkdir(projectAgentsDir, { recursive: true });
+
+    for (const agentFile of agentFiles) {
+      await copyManagedFile(join(packagedAgentsDir, agentFile), join(projectAgentsDir, agentFile), {
+        updateIfDifferent: false,
+        label: `Wingman agent ${agentFile}`,
+      });
+    }
+
+    console.log("✅ OpenCode autopilot assets installed");
+    console.log("   Available slash command: /autopilot on");
+    console.log("   Available Wingman agents: see .opencode/agents/");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("❌ Failed to install OpenCode assets:", message);
+    console.log("   You can manually copy assets from the package .opencode directory.");
+  }
+}
+
+installAssets();