@kody-ade/kody-engine 0.2.11 → 0.2.13

package/dist/bin/kody2.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.2.11",
+  version: "0.2.13",
   description: "kody2 \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -17,7 +17,7 @@ var package_default = {
   ],
   scripts: {
     kody2: "tsx bin/kody2.ts",
-    build: `tsup && node -e "require('fs').cpSync('src/executables', 'dist/executables', { recursive: true })"`,
+    build: "tsup && node scripts/copy-assets.cjs",
     test: "vitest run tests/unit tests/int --no-coverage",
     "test:e2e": "vitest run tests/e2e --no-coverage",
     "test:all": "vitest run tests --no-coverage",
@@ -49,6 +49,15 @@ var package_default = {
   bugs: "https://github.com/aharonyaircohen/kody-engine/issues"
 };
 
+// src/executor.ts
+import * as fs14 from "fs";
+import * as path12 from "path";
+
+// src/agent.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
 // src/config.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -151,15 +160,6 @@ function getAnthropicApiKeyOrDummy() {
   return process.env.ANTHROPIC_API_KEY || `sk-ant-api03-${"0".repeat(64)}`;
 }
 
-// src/executor.ts
-import * as fs13 from "fs";
-import * as path11 from "path";
-
-// src/agent.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import { query } from "@anthropic-ai/claude-agent-sdk";
-
 // src/format.ts
 function renderEvent(msg, opts = {}) {
   if (opts.quiet) {
@@ -289,6 +289,15 @@ async function runAgent(opts) {
     if (opts.mcpServers && opts.mcpServers.length > 0) {
       queryOptions.mcpServers = opts.mcpServers;
     }
+    if (opts.pluginPaths && opts.pluginPaths.length > 0) {
+      queryOptions.plugins = opts.pluginPaths.map((p) => ({ type: "local", path: p }));
+    }
+    if (typeof opts.maxTurns === "number" && opts.maxTurns > 0) {
+      queryOptions.maxTurns = opts.maxTurns;
+    }
+    if (typeof opts.systemPromptAppend === "string" && opts.systemPromptAppend.length > 0) {
+      queryOptions.systemPrompt = { type: "preset", preset: "claude_code", append: opts.systemPromptAppend };
+    }
     const result = query({
       prompt: opts.prompt,
       // biome-ignore lint/suspicious/noExplicitAny: SDK options type is narrow; mcpServers is runtime-passthrough.
@@ -540,19 +549,13 @@ function parseClaudeCode(p, raw) {
     throw new ProfileError(p, `claudeCode.permissionMode must be one of default|acceptEdits|plan|bypassPermissions`);
   }
   const tools = Array.isArray(r.tools) ? r.tools : [];
-  const hooksRaw = r.hooks ?? {};
-  const hooks = {
-    PreToolUse: Array.isArray(hooksRaw.PreToolUse) ? hooksRaw.PreToolUse : [],
-    PostToolUse: Array.isArray(hooksRaw.PostToolUse) ? hooksRaw.PostToolUse : [],
-    Stop: Array.isArray(hooksRaw.Stop) ? hooksRaw.Stop : []
-  };
   return {
     model: typeof r.model === "string" ? r.model : "inherit",
     permissionMode,
     maxTurns: typeof r.maxTurns === "number" ? r.maxTurns : null,
     systemPromptAppend: typeof r.systemPromptAppend === "string" ? r.systemPromptAppend : null,
     tools,
-    hooks,
+    hooks: Array.isArray(r.hooks) ? r.hooks : [],
     skills: Array.isArray(r.skills) ? r.skills : [],
     commands: Array.isArray(r.commands) ? r.commands : [],
     subagents: Array.isArray(r.subagents) ? r.subagents : [],
@@ -617,6 +620,99 @@ function parseScriptList(p, key, raw) {
   return out;
 }
 
+// src/scripts/buildSyntheticPlugin.ts
+import * as fs5 from "fs";
+import * as os2 from "os";
+import * as path5 from "path";
+function getPluginsCatalogRoot() {
+  const here = path5.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    path5.join(here, "..", "plugins"),
+    // dev: src/scripts → src/plugins
+    path5.join(here, "..", "..", "plugins"),
+    // built: dist/scripts → dist/plugins
+    path5.join(here, "..", "..", "src", "plugins")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c) && fs5.statSync(c).isDirectory()) return c;
+  }
+  return candidates[0];
+}
+var buildSyntheticPlugin = async (ctx, profile) => {
+  const cc = profile.claudeCode;
+  const needsSynthetic = cc.skills.length > 0 || cc.commands.length > 0 || cc.hooks.length > 0 || cc.subagents.length > 0;
+  if (!needsSynthetic) return;
+  const catalog = getPluginsCatalogRoot();
+  const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const root = path5.join(os2.tmpdir(), `kody2-synth-${runId}`);
+  fs5.mkdirSync(path5.join(root, ".claude-plugin"), { recursive: true });
+  if (cc.skills.length > 0) {
+    const dst = path5.join(root, "skills");
+    fs5.mkdirSync(dst, { recursive: true });
+    for (const name of cc.skills) {
+      const src = path5.join(catalog, "skills", name);
+      if (!fs5.existsSync(src)) throw new Error(`buildSyntheticPlugin: skill not found in catalog: ${name}`);
+      copyDir(src, path5.join(dst, name));
+    }
+  }
+  if (cc.commands.length > 0) {
+    const dst = path5.join(root, "commands");
+    fs5.mkdirSync(dst, { recursive: true });
+    for (const name of cc.commands) {
+      const src = path5.join(catalog, "commands", `${name}.md`);
+      if (!fs5.existsSync(src)) throw new Error(`buildSyntheticPlugin: command not found in catalog: ${name}`);
+      fs5.copyFileSync(src, path5.join(dst, `${name}.md`));
+    }
+  }
+  if (cc.subagents.length > 0) {
+    const dst = path5.join(root, "agents");
+    fs5.mkdirSync(dst, { recursive: true });
+    for (const name of cc.subagents) {
+      const src = path5.join(catalog, "agents", `${name}.md`);
+      if (!fs5.existsSync(src)) throw new Error(`buildSyntheticPlugin: subagent not found in catalog: ${name}`);
+      fs5.copyFileSync(src, path5.join(dst, `${name}.md`));
+    }
+  }
+  if (cc.hooks.length > 0) {
+    const dst = path5.join(root, "hooks");
+    fs5.mkdirSync(dst, { recursive: true });
+    const merged = { hooks: {} };
+    for (const name of cc.hooks) {
+      const src = path5.join(catalog, "hooks", `${name}.json`);
+      if (!fs5.existsSync(src)) throw new Error(`buildSyntheticPlugin: hook not found in catalog: ${name}`);
+      const parsed = JSON.parse(fs5.readFileSync(src, "utf-8"));
+      for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
+        if (!Array.isArray(entries)) continue;
+        if (!merged.hooks[event]) merged.hooks[event] = [];
+        merged.hooks[event].push(...entries);
+      }
+    }
+    fs5.writeFileSync(path5.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+`);
+  }
+  const manifest = {
+    name: `kody2-synth-${profile.name}`,
+    version: "1.0.0",
+    description: `Synthetic plugin assembled by Kody2 for profile '${profile.name}' at runtime.`
+  };
+  if (cc.skills.length > 0) manifest.skills = ["./skills/"];
+  if (cc.commands.length > 0) manifest.commands = ["./commands/"];
+  if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
+  fs5.writeFileSync(path5.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+  ctx.data.syntheticPluginPath = root;
+};
+function copyDir(src, dst) {
+  fs5.mkdirSync(dst, { recursive: true });
+  for (const ent of fs5.readdirSync(src, { withFileTypes: true })) {
+    const s = path5.join(src, ent.name);
+    const d = path5.join(dst, ent.name);
+    if (ent.isDirectory()) copyDir(s, d);
+    else if (ent.isFile()) fs5.copyFileSync(s, d);
+  }
+}
+
 // src/coverage.ts
 import { execFileSync as execFileSync2 } from "child_process";
 function patternToRegex(pattern) {
@@ -679,18 +775,18 @@ function formatMissesForFeedback(misses) {
 }
 
 // src/prompt.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 var CONVENTIONS_PER_FILE_MAX_BYTES = 3e4;
 var CONVENTION_FILES = ["CLAUDE.md", "AGENTS.md"];
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path5.join(projectDir, rel);
-    if (!fs5.existsSync(abs)) continue;
+    const abs = path6.join(projectDir, rel);
+    if (!fs6.existsSync(abs)) continue;
     let content;
     try {
-      content = fs5.readFileSync(abs, "utf-8");
+      content = fs6.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -767,8 +863,8 @@ import { execFileSync as execFileSync4 } from "child_process";
 
 // src/commit.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -823,18 +919,18 @@ function tryGit(args, cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path6.join(cwd ?? process.cwd(), ".git");
-  if (!fs6.existsSync(gitDir)) return aborted;
-  if (fs6.existsSync(path6.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path7.join(cwd ?? process.cwd(), ".git");
+  if (!fs7.existsSync(gitDir)) return aborted;
+  if (fs7.existsSync(path7.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs6.existsSync(path6.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs7.existsSync(path7.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs6.existsSync(path6.join(gitDir, "REVERT_HEAD"))) {
+  if (fs7.existsSync(path7.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs6.existsSync(path6.join(gitDir, "rebase-merge")) || fs6.existsSync(path6.join(gitDir, "rebase-apply"))) {
+  if (fs7.existsSync(path7.join(gitDir, "rebase-merge")) || fs7.existsSync(path7.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -876,7 +972,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs6.existsSync(path6.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs7.existsSync(path7.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -919,13 +1015,14 @@ function hasCommitsAhead(branch, defaultBranch, cwd) {
 }
 
 // src/scripts/commitAndPush.ts
-var commitAndPush2 = async (ctx) => {
+var commitAndPush2 = async (ctx, profile) => {
   const branch = ctx.data.branch;
   if (!branch) {
     ctx.data.commitResult = { committed: false, pushed: false };
     return;
   }
-  if (ctx.args.mode === "resolve") {
+  const kind = profile.name;
+  if (kind === "resolve") {
     try {
       execFileSync4("git", ["add", "-A"], { cwd: ctx.cwd, env: { ...process.env, HUSKY: "0" }, stdio: "pipe" });
     } catch {
@@ -937,7 +1034,7 @@ var commitAndPush2 = async (ctx) => {
 `);
     }
   }
-  const fallbackMsg = defaultCommitMessage(ctx.args.mode, ctx.data);
+  const fallbackMsg = defaultCommitMessage(kind, ctx.data);
   const message = ctx.data.commitMessage || fallbackMsg;
   try {
     const result = commitAndPush(branch, message, ctx.cwd);
@@ -965,20 +1062,20 @@ function defaultCommitMessage(mode, data) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
 var composePrompt = async (ctx, profile) => {
   const explicit = ctx.data.promptTemplate;
   const mode = ctx.args.mode;
   const candidates = [
-    explicit ? path7.join(profile.dir, explicit) : null,
-    mode ? path7.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path7.join(profile.dir, "prompt.md")
+    explicit ? path8.join(profile.dir, explicit) : null,
+    mode ? path8.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path8.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs7.existsSync(c)) {
+    if (fs8.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -986,7 +1083,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs7.readFileSync(templatePath, "utf-8");
+  const template = fs8.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -1458,7 +1555,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd) {
 
 // src/gha.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -1469,10 +1566,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs8.existsSync(eventPath)) return;
+  if (!eventPath || !fs9.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs8.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs9.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -1671,35 +1768,35 @@ function tryPostPr2(prNumber, body, cwd) {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 
 // src/registry.ts
-import * as fs9 from "fs";
-import * as path8 from "path";
+import * as fs10 from "fs";
+import * as path9 from "path";
 function getExecutablesRoot() {
-  const here = path8.dirname(new URL(import.meta.url).pathname);
+  const here = path9.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path8.join(here, "executables"),
+    path9.join(here, "executables"),
     // dev: src/
-    path8.join(here, "..", "executables"),
+    path9.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path8.join(here, "..", "src", "executables")
+    path9.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs9.existsSync(c) && fs9.statSync(c).isDirectory()) return c;
+    if (fs10.existsSync(c) && fs10.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listExecutables(root = getExecutablesRoot()) {
-  if (!fs9.existsSync(root)) return [];
-  const entries = fs9.readdirSync(root, { withFileTypes: true });
+  if (!fs10.existsSync(root)) return [];
+  const entries = fs10.readdirSync(root, { withFileTypes: true });
   const out = [];
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const profilePath = path8.join(root, ent.name, "profile.json");
-    if (fs9.existsSync(profilePath) && fs9.statSync(profilePath).isFile()) {
+    const profilePath = path9.join(root, ent.name, "profile.json");
+    if (fs10.existsSync(profilePath) && fs10.statSync(profilePath).isFile()) {
       out.push({ name: ent.name, profilePath });
     }
   }
@@ -1707,8 +1804,8 @@ function listExecutables(root = getExecutablesRoot()) {
 }
 function hasExecutable(name, root = getExecutablesRoot()) {
   if (!isSafeName(name)) return false;
-  const profilePath = path8.join(root, name, "profile.json");
-  return fs9.existsSync(profilePath) && fs9.statSync(profilePath).isFile();
+  const profilePath = path9.join(root, name, "profile.json");
+  return fs10.existsSync(profilePath) && fs10.statSync(profilePath).isFile();
 }
 function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
@@ -1724,11 +1821,11 @@ function parseGenericFlags(argv) {
     }
     const key = arg.slice(2);
     const next = argv[i + 1];
-    if (next !== void 0 && !next.startsWith("--")) {
-      args[key] = next;
-      i++;
-    } else {
-      args[key] = true;
+    const value = next !== void 0 && !next.startsWith("--") ? (i++, next) : true;
+    args[key] = value;
+    if (key.includes("-")) {
+      const camel = key.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+      if (camel !== key && args[camel] === void 0) args[camel] = value;
     }
   }
   if (positional.length > 0) args._ = positional;
@@ -1737,9 +1834,9 @@ function parseGenericFlags(argv) {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs10.existsSync(path9.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs10.existsSync(path9.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs10.existsSync(path9.join(cwd, "bun.lockb"))) return "bun";
+  if (fs11.existsSync(path10.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs11.existsSync(path10.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs11.existsSync(path10.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -1860,22 +1957,22 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path9.join(cwd, "kody.config.json");
-  if (fs10.existsSync(configPath) && !force) {
+  const configPath = path10.join(cwd, "kody.config.json");
+  if (fs11.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs10.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs11.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path9.join(cwd, ".github", "workflows");
-  const workflowPath = path9.join(workflowDir, "kody2.yml");
-  if (fs10.existsSync(workflowPath) && !force) {
+  const workflowDir = path10.join(cwd, ".github", "workflows");
+  const workflowPath = path10.join(workflowDir, "kody2.yml");
+  if (fs11.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody2.yml");
   } else {
-    fs10.mkdirSync(workflowDir, { recursive: true });
-    fs10.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs11.mkdirSync(workflowDir, { recursive: true });
+    fs11.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody2.yml");
   }
   for (const exe of listExecutables()) {
@@ -1886,12 +1983,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path9.join(workflowDir, `kody2-${exe.name}.yml`);
-    if (fs10.existsSync(target) && !force) {
+    const target = path10.join(workflowDir, `kody2-${exe.name}.yml`);
+    if (fs11.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody2-${exe.name}.yml`);
       continue;
     }
-    fs10.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs11.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody2-${exe.name}.yml`);
   }
   return { wrote, skipped };
@@ -2307,8 +2404,8 @@ REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.
 
 // src/scripts/releaseFlow.ts
 import { execFileSync as execFileSync11, spawnSync } from "child_process";
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs12 from "fs";
+import * as path11 from "path";
 function bumpVersion(current, bump) {
   const m = current.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
   if (!m) throw new Error(`cannot parse version '${current}' (expected x.y.z[-suffix])`);
@@ -2324,12 +2421,12 @@ function bumpVersion(current, bump) {
   return `${major}.${minor}.${patch}`;
 }
 function updateVersionInFile(file, newVersion, cwd) {
-  const abs = path10.join(cwd, file);
-  if (!fs11.existsSync(abs)) return false;
-  const content = fs11.readFileSync(abs, "utf-8");
+  const abs = path11.join(cwd, file);
+  if (!fs12.existsSync(abs)) return false;
+  const content = fs12.readFileSync(abs, "utf-8");
   const updated = content.replace(/"version"\s*:\s*"[^"]+"/, `"version": "${newVersion}"`);
   if (updated === content) return false;
-  fs11.writeFileSync(abs, updated);
+  fs12.writeFileSync(abs, updated);
   return true;
 }
 function generateChangelog(cwd, newVersion, lastTag) {
@@ -2377,19 +2474,19 @@ function generateChangelog(cwd, newVersion, lastTag) {
   return parts.join("\n");
 }
 function prependChangelog(cwd, entry) {
-  const p = path10.join(cwd, "CHANGELOG.md");
+  const p = path11.join(cwd, "CHANGELOG.md");
   const header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n";
-  if (fs11.existsSync(p)) {
-    const prior = fs11.readFileSync(p, "utf-8");
+  if (fs12.existsSync(p)) {
+    const prior = fs12.readFileSync(p, "utf-8");
     if (/^#\s*Changelog\b/m.test(prior)) {
       const idx = prior.indexOf("\n", prior.indexOf("# Changelog"));
-      fs11.writeFileSync(p, `${prior.slice(0, idx + 1)}
+      fs12.writeFileSync(p, `${prior.slice(0, idx + 1)}
 ${entry}${prior.slice(idx + 1)}`);
     } else {
-      fs11.writeFileSync(p, `${header}${entry}${prior}`);
+      fs12.writeFileSync(p, `${header}${entry}${prior}`);
     }
   } else {
-    fs11.writeFileSync(p, `${header}${entry}`);
+    fs12.writeFileSync(p, `${header}${entry}`);
   }
 }
 function git3(args, cwd, timeout = 6e4) {
@@ -2440,13 +2537,13 @@ var releaseFlow = async (ctx) => {
 };
 async function runPrepare(args) {
   const { cwd, bump, dryRun, versionFiles, ctx } = args;
-  const pkgPath = path10.join(cwd, "package.json");
-  if (!fs11.existsSync(pkgPath)) {
+  const pkgPath = path11.join(cwd, "package.json");
+  if (!fs12.existsSync(pkgPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release prepare: package.json not found";
     return;
   }
-  const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+  const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
   if (typeof pkg.version !== "string") {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release prepare: package.json has no version";
@@ -2517,8 +2614,8 @@ Merge this and then run \`kody2 release --mode finalize\`.`;
 }
 async function runFinalize(args) {
   const { cwd, dryRun, timeoutMs, releaseCfg, ctx } = args;
-  const pkgPath = path10.join(cwd, "package.json");
-  const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path11.join(cwd, "package.json");
+  const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
   if (typeof pkg.version !== "string") {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release finalize: package.json has no version";
@@ -2789,7 +2886,7 @@ import { spawn as spawn2 } from "child_process";
 var TAIL_CHARS = 4e3;
 var COMMAND_TIMEOUT_MS = 10 * 60 * 1e3;
 function runCommand(command, cwd) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const start = Date.now();
     const child = spawn2(command, {
       cwd,
@@ -2818,11 +2915,11 @@ function runCommand(command, cwd) {
     child.on("exit", (code) => {
       clearTimeout(timer);
       const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
-      resolve2({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+      resolve3({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve2({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+      resolve3({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
     });
   });
 }
@@ -2948,11 +3045,11 @@ var watchStalePrsFlow = async (ctx) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs12 from "fs";
-var writeRunSummary = async (ctx) => {
+import * as fs13 from "fs";
+var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
-  const mode = ctx.args.mode;
+  const executable = profile.name;
   const issue = ctx.args.issue;
   const pr = ctx.args.pr;
   const target = issue ? `issue #${issue}` : pr ? `PR #${pr}` : "(unknown)";
@@ -2961,16 +3058,16 @@ var writeRunSummary = async (ctx) => {
   const reason = ctx.output.reason;
   const status = exitCode === 0 ? "\u2705 success" : exitCode === 3 ? "\u23ED\uFE0F no-op" : "\u26A0\uFE0F failed";
   const lines = [];
-  lines.push(`## kody2 run \u2014 ${status}`);
+  lines.push(`## kody2 ${executable} \u2014 ${status}`);
   lines.push("");
-  lines.push(`- **Mode:** \`${mode ?? "?"}\``);
+  lines.push(`- **Executable:** \`${executable}\``);
   lines.push(`- **Target:** ${target}`);
   if (prUrl) lines.push(`- **PR:** ${prUrl}`);
   lines.push(`- **Exit code:** ${exitCode}`);
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs12.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs13.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -2990,6 +3087,7 @@ var preflightScripts = {
   loadIssueContext,
   loadConventions,
   loadCoverageRules,
+  buildSyntheticPlugin,
   composePrompt
 };
 var postflightScripts = {
@@ -3068,7 +3166,24 @@ async function runExecutable(profileName, input) {
   if (firstFail) {
     return finish({ exitCode: 99, reason: `required CLI tool check failed: ${firstFail.error}` });
   }
-  const modelSpec = profile.claudeCode.model === "inherit" ? input.config.agent.model : profile.claudeCode.model;
+  let config;
+  if (input.config) {
+    config = input.config;
+  } else if (input.skipConfig) {
+    config = {
+      quality: { typecheck: "", lint: "", testUnit: "" },
+      git: { defaultBranch: "main" },
+      github: { owner: "", repo: "" },
+      agent: { model: "claude/claude-haiku-4-5-20251001" }
+    };
+  } else {
+    try {
+      config = loadConfig(input.cwd);
+    } catch (err) {
+      return finish({ exitCode: 99, reason: `config error: ${err instanceof Error ? err.message : String(err)}` });
+    }
+  }
+  const modelSpec = profile.claudeCode.model === "inherit" ? config.agent.model : profile.claudeCode.model;
   let model;
   try {
     model = parseProviderModel(modelSpec);
@@ -3087,25 +3202,33 @@ async function runExecutable(profileName, input) {
   const ctx = {
     args,
     cwd: input.cwd,
-    config: input.config,
+    config,
     verbose: input.verbose,
     quiet: input.quiet,
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path11.join(input.cwd, ".kody2");
-  const invokeAgent = async (prompt) => runAgent({
-    prompt,
-    model,
-    cwd: input.cwd,
-    litellmUrl: litellm?.url ?? null,
-    verbose: input.verbose,
-    quiet: input.quiet,
-    ndjsonDir,
-    allowedToolsOverride: profile.claudeCode.tools,
-    permissionModeOverride: profile.claudeCode.permissionMode,
-    mcpServers: profile.claudeCode.mcpServers
-  });
+  const ndjsonDir = path12.join(input.cwd, ".kody2");
+  const invokeAgent = async (prompt) => {
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path12.isAbsolute(p) ? p : path12.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const syntheticPath = ctx.data.syntheticPluginPath;
+    const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
+    return runAgent({
+      prompt,
+      model,
+      cwd: input.cwd,
+      litellmUrl: litellm?.url ?? null,
+      verbose: input.verbose,
+      quiet: input.quiet,
+      ndjsonDir,
+      allowedToolsOverride: profile.claudeCode.tools,
+      permissionModeOverride: profile.claudeCode.permissionMode,
+      mcpServers: profile.claudeCode.mcpServers,
+      pluginPaths: pluginPaths.length > 0 ? pluginPaths : void 0,
+      maxTurns: profile.claudeCode.maxTurns,
+      systemPromptAppend: profile.claudeCode.systemPromptAppend
+    });
+  };
   ctx.data.__invokeAgent = invokeAgent;
   try {
     for (const entry of profile.scripts.preflight) {
@@ -3152,22 +3275,36 @@ async function runExecutable(profileName, input) {
   }
 }
 function resolveProfilePath(profileName) {
-  const here = path11.dirname(new URL(import.meta.url).pathname);
+  const here = path12.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path11.join(here, "executables", profileName, "profile.json"),
+    path12.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path11.join(here, "..", "executables", profileName, "profile.json"),
+    path12.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path11.join(here, "..", "src", "executables", profileName, "profile.json")
+    path12.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs13.existsSync(c)) return c;
+    if (fs14.existsSync(c)) return c;
   }
   return candidates[0];
 }
 function validateInputs(specs, raw) {
   const out = {};
+  const allowedKeys = /* @__PURE__ */ new Set(["_", "cwd", "verbose", "quiet"]);
+  for (const spec of specs) {
+    const flagKey = spec.flag.replace(/^--/, "");
+    allowedKeys.add(spec.name);
+    allowedKeys.add(flagKey);
+    if (flagKey.includes("-")) {
+      allowedKeys.add(flagKey.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase()));
+    }
+  }
+  for (const key of Object.keys(raw)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`unknown arg: --${key}`);
+    }
+  }
   for (const spec of specs) {
     const v = raw[spec.name];
     if (v === void 0 || v === null) continue;
@@ -3241,33 +3378,33 @@ function finish(out) {
 
 // src/kody2-cli.ts
 import { execFileSync as execFileSync14 } from "child_process";
-import * as fs15 from "fs";
-import * as path12 from "path";
+import * as fs16 from "fs";
+import * as path13 from "path";
 
 // src/dispatch.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 function autoDispatch(opts) {
   const explicit = opts?.explicit;
   if (explicit?.issueNumber && explicit.issueNumber > 0) {
     return {
-      executable: "build",
-      cliArgs: { mode: "run", issue: explicit.issueNumber },
+      executable: "run",
+      cliArgs: { issue: explicit.issueNumber },
       target: explicit.issueNumber
     };
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs14.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs15.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs14.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs15.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
   if (eventName === "workflow_dispatch") {
     const n = parseInt(String(event.inputs?.issue_number ?? ""), 10);
     if (!Number.isNaN(n) && n > 0) {
-      return { executable: "build", cliArgs: { mode: "run", issue: n }, target: n };
+      return { executable: "run", cliArgs: { issue: n }, target: n };
     }
     return null;
   }
@@ -3279,35 +3416,35 @@ function autoDispatch(opts) {
   const afterTag = extractAfterTag(body);
   if (isPr) {
     if (/\bfix-ci\b/.test(afterTag)) {
-      return { executable: "build", cliArgs: { mode: "fix-ci", pr: targetNum }, target: targetNum };
+      return { executable: "fix-ci", cliArgs: { pr: targetNum }, target: targetNum };
     }
     if (/\bresolve\b/.test(afterTag)) {
-      return { executable: "build", cliArgs: { mode: "resolve", pr: targetNum }, target: targetNum };
+      return { executable: "resolve", cliArgs: { pr: targetNum }, target: targetNum };
+    }
+    if (/\breview\b/.test(afterTag)) {
+      return { executable: "review", cliArgs: { pr: targetNum }, target: targetNum };
     }
     const feedback = extractFeedback(afterTag);
     return {
-      executable: "build",
-      cliArgs: { mode: "fix", pr: targetNum, ...feedback ? { feedback } : {} },
+      executable: "fix",
+      cliArgs: { pr: targetNum, ...feedback ? { feedback } : {} },
       target: targetNum
     };
   }
   const sub = extractSubcommand(afterTag);
-  const defaultExec = opts?.config?.defaultExecutable ?? "build";
+  const defaultExec = opts?.config?.defaultExecutable ?? "run";
   if (!sub) {
     return asDispatch(defaultExec, targetNum);
   }
-  if (sub === "build") {
-    return { executable: "build", cliArgs: { mode: "run", issue: targetNum }, target: targetNum };
-  }
   if (sub === "orchestrate" || sub === "orchestrator") {
     return { executable: "orchestrator", cliArgs: { issue: targetNum }, target: targetNum };
   }
+  if (sub === "build") {
+    return { executable: "run", cliArgs: { issue: targetNum }, target: targetNum };
+  }
   return asDispatch(sub, targetNum);
 }
 function asDispatch(executable, target) {
-  if (executable === "build") {
-    return { executable, cliArgs: { mode: "run", issue: target }, target };
-  }
   return { executable, cliArgs: { issue: target }, target };
 }
 function extractAfterTag(body) {
@@ -3410,9 +3547,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs15.existsSync(path12.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs15.existsSync(path12.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs15.existsSync(path12.join(cwd, "bun.lockb"))) return "bun";
+  if (fs16.existsSync(path13.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs16.existsSync(path13.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs16.existsSync(path13.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -3489,11 +3626,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path12.join(cwd, ".kody2", "last-run.jsonl");
+  const logPath = path13.join(cwd, ".kody2", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs15.existsSync(logPath)) {
-      const content = fs15.readFileSync(logPath, "utf-8");
+    if (fs16.existsSync(logPath)) {
+      const content = fs16.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -3518,7 +3655,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path12.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path13.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -3537,8 +3674,8 @@ ${CI_HELP}`);
     return 64;
   }
   const dispatch = autoFallback ?? {
-    executable: "build",
-    cliArgs: { mode: "run", issue: args.issueNumber },
+    executable: "run",
+    cliArgs: { issue: args.issueNumber },
     target: args.issueNumber
   };
   const issueNumber = dispatch.target;
@@ -3610,16 +3747,19 @@ ${CI_HELP}`);
 var HELP_TEXT = `kody2 \u2014 single-session autonomous engineer
 
 Usage:
-  kody2 run     --issue <N> [--cwd <path>] [--verbose|--quiet] [--dry-run]
-  kody2 ci      --issue <N> [preflight flags \u2014 see: kody2 ci --help]
+  kody2 run     --issue <N> [--cwd <path>] [--verbose|--quiet]
   kody2 fix     --pr    <N> [--feedback "..."] [--cwd <path>] [--verbose|--quiet]
   kody2 fix-ci  --pr    <N> [--run-id <ID>]    [--cwd <path>] [--verbose|--quiet]
   kody2 resolve --pr    <N>                    [--cwd <path>] [--verbose|--quiet]
+  kody2 review  --pr    <N>                    [--cwd <path>] [--verbose|--quiet]
+  kody2 <other>                                [--cwd <path>] [--verbose|--quiet]
+  kody2 ci      --issue <N> [preflight flags \u2014 see: kody2 ci --help]
   kody2 help
   kody2 version
 
-All commands dispatch to the Build executable with a specific mode. The
-executable is defined by \`src/executables/build/profile.json\`.
+Each top-level command (run, fix, fix-ci, resolve, review, \u2026) is a discovered
+executable under \`src/executables/<name>/profile.json\`. Drop in a new
+directory to add a new command.
 
 Exit codes:
   0   success (PR opened, verify passed \u2014 or resolve produced a merge commit)
@@ -3640,11 +3780,6 @@ function parseArgs(argv) {
   if (cmd === "ci") {
     return { ...result, command: "ci", ciArgv: argv.slice(1) };
   }
-  if (cmd === "run" || cmd === "fix" || cmd === "fix-ci" || cmd === "resolve") {
-    result.command = cmd;
-    parseCommandArgs(cmd, argv.slice(1), result);
-    return result;
-  }
   if (hasExecutable(cmd)) {
     result.command = "__executable__";
     result.executableName = cmd;
@@ -3654,38 +3789,11 @@ function parseArgs(argv) {
     if (result.cliArgs.quiet === true) result.quiet = true;
     return result;
   }
-  const discovered = listExecutables().map((e) => e.name).filter((n) => n !== "build");
-  const available = ["run", "fix", "fix-ci", "resolve", "ci", "help", "version", ...discovered];
+  const discovered = listExecutables().map((e) => e.name);
+  const available = ["ci", "help", "version", ...discovered];
   result.errors.push(`unknown command: ${cmd} (available: ${available.join(", ")})`);
   return result;
 }
-function parseCommandArgs(cmd, rest, result) {
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i];
-    if (arg === "--issue") {
-      const n = parseInt(rest[++i] ?? "", 10);
-      if (Number.isNaN(n) || n <= 0) result.errors.push("--issue requires a positive integer");
-      else result.issueNumber = n;
-    } else if (arg === "--pr") {
-      const n = parseInt(rest[++i] ?? "", 10);
-      if (Number.isNaN(n) || n <= 0) result.errors.push("--pr requires a positive integer");
-      else result.prNumber = n;
-    } else if (arg === "--feedback") {
-      result.feedback = rest[++i];
-    } else if (arg === "--run-id") {
-      result.runId = rest[++i];
-    } else if (arg === "--cwd") {
-      result.cwd = rest[++i];
-    } else if (arg === "--verbose") result.verbose = true;
-    else if (arg === "--quiet") result.quiet = true;
-    else if (arg === "--dry-run") result.dryRun = true;
-    else result.errors.push(`unknown arg: ${arg}`);
-  }
-  if (cmd === "run" && !result.issueNumber) result.errors.push("--issue <N> is required for run");
-  if (cmd === "fix" && !result.prNumber) result.errors.push("--pr <N> is required for fix");
-  if (cmd === "fix-ci" && !result.prNumber) result.errors.push("--pr <N> is required for fix-ci");
-  if (cmd === "resolve" && !result.prNumber) result.errors.push("--pr <N> is required for resolve");
-}
 async function main(argv = process.argv.slice(2)) {
   const args = parseArgs(argv);
   if (args.errors.length > 0) {
@@ -3718,69 +3826,27 @@ ${HELP_TEXT}`);
   }
   const cwd = args.cwd ?? process.cwd();
   const configlessCommands = /* @__PURE__ */ new Set(["init"]);
-  const needsConfig = !(args.command === "__executable__" && configlessCommands.has(args.executableName ?? ""));
-  let config;
-  if (needsConfig) {
-    try {
-      config = loadConfig(cwd);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[kody2] config error: ${msg}
-`);
-      process.stdout.write(`PR_URL=FAILED: config error: ${msg}
-`);
-      return 99;
-    }
-  } else {
-    config = {
-      quality: { typecheck: "", lint: "", testUnit: "" },
-      git: { defaultBranch: "main" },
-      github: { owner: "", repo: "" },
-      agent: { model: "claude/claude-haiku-4-5-20251001" }
-    };
-  }
-  if (args.command === "__executable__") {
-    try {
-      const result = await runExecutable(args.executableName, {
-        cliArgs: args.cliArgs ?? {},
-        cwd,
-        config,
-        verbose: args.verbose,
-        quiet: args.quiet
-      });
-      return result.exitCode;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[kody2] ${args.executableName} crashed: ${msg}
-`);
-      if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
-`);
-      process.stdout.write(`PR_URL=FAILED: ${args.executableName} crashed: ${msg}
-`);
-      return 99;
-    }
-  }
-  const cliArgs = { mode: args.command };
-  if (args.issueNumber !== void 0) cliArgs.issue = args.issueNumber;
-  if (args.prNumber !== void 0) cliArgs.pr = args.prNumber;
-  if (args.feedback !== void 0) cliArgs.feedback = args.feedback;
-  if (args.runId !== void 0) cliArgs.runId = args.runId;
+  const skipConfig = configlessCommands.has(args.executableName ?? "");
   try {
-    const result = await runExecutable("build", {
-      cliArgs,
+    const result = await runExecutable(args.executableName, {
+      cliArgs: args.cliArgs ?? {},
       cwd,
-      config,
+      skipConfig,
       verbose: args.verbose,
       quiet: args.quiet
     });
+    if (result.exitCode !== 0 && result.reason) {
+      process.stderr.write(`error: ${result.reason}
+`);
+    }
     return result.exitCode;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[kody2] wrapper crashed: ${msg}
+    process.stderr.write(`[kody2] ${args.executableName} crashed: ${msg}
 `);
     if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
 `);
-    process.stdout.write(`PR_URL=FAILED: wrapper crashed: ${msg}
+    process.stdout.write(`PR_URL=FAILED: ${args.executableName} crashed: ${msg}
 `);
     return 99;
   }