opencodekit 0.12.7 → 0.13.1

package/dist/index.js

@@ -750,7 +750,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "opencodekit",
-  version: "0.12.7",
+  version: "0.13.1",
   description: "CLI tool for bootstrapping and managing OpenCodeKit projects",
   type: "module",
   repository: {
@@ -767,7 +767,7 @@ var package_default = {
   files: ["dist", "README.md"],
   scripts: {
     dev: "bun run src/index.ts",
-    build: "bun build src/index.ts --outdir dist --target node && mkdir -p dist/template && rsync -av --exclude=node_modules --exclude=dist --exclude=.git --exclude=coverage --exclude=.next --exclude=.turbo --exclude=logs --exclude=package-lock.json .opencode/ dist/template/.opencode/",
+    build: "bun run build.ts && mkdir -p dist/template && rsync -av --exclude=node_modules --exclude=dist --exclude=.git --exclude=coverage --exclude=.next --exclude=.turbo --exclude=logs --exclude=package-lock.json .opencode/ dist/template/.opencode/",
     compile: "bun build src/index.ts --compile --outfile ock",
     "compile:binary": "bun build src/index.ts --compile --outfile bin/ock",
     typecheck: "tsc --noEmit",
@@ -785,11 +785,14 @@ var package_default = {
   dependencies: {
     "@clack/prompts": "^0.7.0",
     "@opencode-ai/plugin": "^1.1.2",
+    "@opentui/core": "^0.1.69",
+    "@opentui/solid": "^0.1.69",
     "beads-village": "^1.3.3",
     cac: "^6.7.14",
     "cli-table3": "^0.6.5",
     ora: "^9.0.0",
     picocolors: "^1.1.1",
+    "solid-js": "^1.9.10",
     zod: "^3.23.8"
   },
   devDependencies: {
@@ -809,6 +812,7 @@ import {
   mkdirSync,
   readFileSync,
   readdirSync,
+  unlinkSync,
   writeFileSync
 } from "node:fs";
 import { join } from "node:path";
@@ -1144,6 +1148,41 @@ class BD extends x {
     });
   }
 }
+var fD = Object.defineProperty;
+var gD = (e, u, F) => (u in e) ? fD(e, u, { enumerable: true, configurable: true, writable: true, value: F }) : e[u] = F;
+var K = (e, u, F) => (gD(e, typeof u != "symbol" ? u + "" : u, F), F);
+var vD = class extends x {
+  constructor(u) {
+    super(u, false), K(this, "options"), K(this, "cursor", 0), this.options = u.options, this.value = [...u.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: F }) => F === u.cursorAt), 0), this.on("key", (F) => {
+      F === "a" && this.toggleAll();
+    }), this.on("cursor", (F) => {
+      switch (F) {
+        case "left":
+        case "up":
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          break;
+        case "down":
+        case "right":
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+  get _value() {
+    return this.options[this.cursor].value;
+  }
+  toggleAll() {
+    const u = this.value.length === this.options.length;
+    this.value = u ? [] : this.options.map((F) => F.value);
+  }
+  toggleValue() {
+    const u = this.value.includes(this._value);
+    this.value = u ? this.value.filter((F) => F !== this._value) : [...this.value, this._value];
+  }
+};
 var wD = Object.defineProperty;
 var yD = (e, u, F) => (u in e) ? wD(e, u, { enumerable: true, configurable: true, writable: true, value: F }) : e[u] = F;
 var Z = (e, u, F) => (yD(e, typeof u != "symbol" ? u + "" : u, F), F);
@@ -1227,7 +1266,7 @@ var H = o("◆", "*");
 var I2 = o("■", "x");
 var x2 = o("▲", "x");
 var S2 = o("◇", "o");
-var K = o("┌", "T");
+var K2 = o("┌", "T");
 var a2 = o("│", "|");
 var d2 = o("└", "—");
 var b2 = o("●", ">");
@@ -1325,6 +1364,50 @@ ${import_picocolors2.default.cyan(d2)}
     }
   } }).prompt();
 };
+var ae = (r2) => {
+  const n = (i, t) => {
+    const s = i.label ?? String(i.value);
+    return t === "active" ? `${import_picocolors2.default.cyan(C)} ${s} ${i.hint ? import_picocolors2.default.dim(`(${i.hint})`) : ""}` : t === "selected" ? `${import_picocolors2.default.green(w2)} ${import_picocolors2.default.dim(s)}` : t === "cancelled" ? `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}` : t === "active-selected" ? `${import_picocolors2.default.green(w2)} ${s} ${i.hint ? import_picocolors2.default.dim(`(${i.hint})`) : ""}` : t === "submitted" ? `${import_picocolors2.default.dim(s)}` : `${import_picocolors2.default.dim(M2)} ${import_picocolors2.default.dim(s)}`;
+  };
+  return new vD({ options: r2.options, initialValues: r2.initialValues, required: r2.required ?? true, cursorAt: r2.cursorAt, validate(i) {
+    if (this.required && i.length === 0)
+      return `Please select at least one option.
+${import_picocolors2.default.reset(import_picocolors2.default.dim(`Press ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" space ")))} to select, ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" enter ")))} to submit`))}`;
+  }, render() {
+    let i = `${import_picocolors2.default.gray(a2)}
+${y2(this.state)}  ${r2.message}
+`;
+    switch (this.state) {
+      case "submit":
+        return `${i}${import_picocolors2.default.gray(a2)}  ${this.options.filter(({ value: t }) => this.value.includes(t)).map((t) => n(t, "submitted")).join(import_picocolors2.default.dim(", ")) || import_picocolors2.default.dim("none")}`;
+      case "cancel": {
+        const t = this.options.filter(({ value: s }) => this.value.includes(s)).map((s) => n(s, "cancelled")).join(import_picocolors2.default.dim(", "));
+        return `${i}${import_picocolors2.default.gray(a2)}  ${t.trim() ? `${t}
+${import_picocolors2.default.gray(a2)}` : ""}`;
+      }
+      case "error": {
+        const t = this.error.split(`
+`).map((s, c2) => c2 === 0 ? `${import_picocolors2.default.yellow(d2)}  ${import_picocolors2.default.yellow(s)}` : `   ${s}`).join(`
+`);
+        return i + import_picocolors2.default.yellow(a2) + "  " + this.options.map((s, c2) => {
+          const l2 = this.value.includes(s.value), u = c2 === this.cursor;
+          return u && l2 ? n(s, "active-selected") : l2 ? n(s, "selected") : n(s, u ? "active" : "inactive");
+        }).join(`
+${import_picocolors2.default.yellow(a2)}  `) + `
+` + t + `
+`;
+      }
+      default:
+        return `${i}${import_picocolors2.default.cyan(a2)}  ${this.options.map((t, s) => {
+          const c2 = this.value.includes(t.value), l2 = s === this.cursor;
+          return l2 && c2 ? n(t, "active-selected") : c2 ? n(t, "selected") : n(t, l2 ? "active" : "inactive");
+        }).join(`
+${import_picocolors2.default.cyan(a2)}  `)}
+${import_picocolors2.default.cyan(d2)}
+`;
+    }
+  } }).prompt();
+};
 var R2 = (r2) => r2.replace(me(), "");
 var le = (r2 = "", n = "") => {
   const i = `
@@ -1344,7 +1427,7 @@ var ue = (r2 = "") => {
 `);
 };
 var oe = (r2 = "") => {
-  process.stdout.write(`${import_picocolors2.default.gray(K)}  ${r2}
+  process.stdout.write(`${import_picocolors2.default.gray(K2)}  ${r2}
 `);
 };
 var $e = (r2 = "") => {
@@ -1412,9 +1495,9 @@ var import_picocolors4 = __toESM(require_picocolors(), 1);
 var import_picocolors3 = __toESM(require_picocolors(), 1);
 function showError(message, fix) {
   console.log();
-  f2.error(import_picocolors3.default.red("✗") + " " + message);
+  f2.error(`${import_picocolors3.default.red("✗")} ${message}`);
   if (fix) {
-    f2.info("  " + import_picocolors3.default.dim("→ " + fix));
+    f2.info(`  ${import_picocolors3.default.dim(`→ ${fix}`)}`);
   }
   console.log();
 }
@@ -1425,16 +1508,13 @@ function notFound(resource, name) {
   const msg = name ? `${resource} "${name}" not found` : `${resource} not found`;
   showError(msg);
 }
-function alreadyExists(resource, name) {
-  showError(`${resource} "${name}" already exists`);
-}
 function unknownAction(action, available) {
   showError(`Unknown action: ${action}`, `Available: ${available.map((a3) => import_picocolors3.default.cyan(a3)).join(", ")}`);
 }
 function showWarning(message, suggestion) {
-  f2.warn(import_picocolors3.default.yellow("!") + " " + message);
+  f2.warn(`${import_picocolors3.default.yellow("!")} ${message}`);
   if (suggestion) {
-    f2.info("  " + import_picocolors3.default.dim("→ " + suggestion));
+    f2.info(`  ${import_picocolors3.default.dim(`→ ${suggestion}`)}`);
   }
 }
 function showEmpty(resource, createCmd) {
@@ -1445,18 +1525,6 @@ function showEmpty(resource, createCmd) {
 }
 
 // src/commands/agent.ts
-var AGENT_TEMPLATE = `# {{NAME}} Agent
-
-## Role
-Describe what this agent does.
-
-## Capabilities
-- Capability 1
-- Capability 2
-
-## Instructions
-Provide specific instructions for this agent.
-`;
 async function agentCommand(action) {
   const opencodePath = join(process.cwd(), ".opencode");
   if (!existsSync(opencodePath)) {
@@ -1468,23 +1536,54 @@ async function agentCommand(action) {
     case "list":
       await listAgents(agentPath);
       break;
+    case "create":
+      await createAgent(agentPath);
+      break;
     case "add":
-      await addAgent(agentPath);
+      await createAgent(agentPath);
       break;
     case "view": {
       const agentName = process.argv[4];
       await viewAgent(agentPath, agentName);
       break;
     }
+    case "remove": {
+      const agentName = process.argv[4];
+      await removeAgent(agentPath, agentName);
+      break;
+    }
     default:
-      unknownAction(action, ["list", "add", "view"]);
+      unknownAction(action, ["list", "create", "view", "remove"]);
   }
 }
-async function listAgents(agentPath) {
-  if (!existsSync(agentPath)) {
-    showEmpty("agents", "ock agent add");
-    return;
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match)
+    return {};
+  const frontmatter = {};
+  const lines = match[1].split(`
+`);
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (value.startsWith("[") && value.endsWith("]")) {
+        const items = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+        frontmatter[key] = items;
+      } else {
+        frontmatter[key] = value;
+      }
+    }
   }
+  return frontmatter;
+}
+function collectAgents(agentPath) {
+  if (!existsSync(agentPath))
+    return [];
   const opencodePath = join(process.cwd(), ".opencode");
   const configPath = join(opencodePath, "opencode.json");
   let agentConfigs = {};
@@ -1496,38 +1595,48 @@ async function listAgents(agentPath) {
     } catch {}
   }
   const entries = readdirSync(agentPath);
-  const agents = entries.filter((entry) => {
+  const agents = [];
+  for (const entry of entries) {
     const entryPath = join(agentPath, entry);
-    return lstatSync(entryPath).isFile() && entry.endsWith(".md");
-  }).map((file) => file.replace(".md", ""));
+    if (!lstatSync(entryPath).isFile() || !entry.endsWith(".md"))
+      continue;
+    const name = entry.replace(".md", "");
+    const content = readFileSync(entryPath, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    agents.push({
+      name,
+      path: entryPath,
+      frontmatter,
+      disabled: agentConfigs[name]?.disable,
+      configModel: agentConfigs[name]?.model
+    });
+  }
+  return agents.sort((a3, b3) => a3.name.localeCompare(b3.name));
+}
+async function listAgents(agentPath) {
+  const agents = collectAgents(agentPath);
   if (agents.length === 0) {
-    showEmpty("agents", "ock agent add");
+    showEmpty("agents", "ock agent create");
     return;
   }
   f2.info(import_picocolors4.default.bold("Agents"));
   for (const agent of agents) {
-    let model = agentConfigs[agent]?.model;
-    const disabled = agentConfigs[agent]?.disable;
-    if (!model) {
-      const agentFile = join(agentPath, `${agent}.md`);
-      try {
-        const content = readFileSync(agentFile, "utf-8");
-        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-        if (frontmatterMatch) {
-          const modelMatch = frontmatterMatch[1].match(/^model:\s*(.+)$/m);
-          if (modelMatch) {
-            model = modelMatch[1].trim();
-          }
-        }
-      } catch {}
-    }
+    const model = agent.configModel || agent.frontmatter.model;
+    const mode = agent.frontmatter.mode;
+    const modeDisplay = mode ? import_picocolors4.default.yellow(`[${mode}]`) : "";
     const modelDisplay = model ? import_picocolors4.default.dim(` → ${model}`) : import_picocolors4.default.dim(" → (default)");
-    const disabledDisplay = disabled ? import_picocolors4.default.red(" [disabled]") : "";
-    console.log(`  ${import_picocolors4.default.cyan("•")} ${agent}${modelDisplay}${disabledDisplay}`);
+    const disabledDisplay = agent.disabled ? import_picocolors4.default.red(" [disabled]") : "";
+    const descDisplay = agent.frontmatter.description ? import_picocolors4.default.dim(` - ${agent.frontmatter.description.slice(0, 40)}${agent.frontmatter.description.length > 40 ? "..." : ""}`) : "";
+    console.log(`  ${import_picocolors4.default.cyan("•")} ${agent.name} ${modeDisplay}${modelDisplay}${disabledDisplay}${descDisplay}`);
   }
+  console.log();
+  f2.info(import_picocolors4.default.dim(`Found ${agents.length} agent${agents.length === 1 ? "" : "s"}`));
 }
-async function addAgent(agentPath) {
-  oe(import_picocolors4.default.bgMagenta(import_picocolors4.default.black(" Add Agent ")));
+async function createAgent(agentPath) {
+  oe(import_picocolors4.default.bgMagenta(import_picocolors4.default.black(" Create Agent ")));
+  if (!existsSync(agentPath)) {
+    mkdirSync(agentPath, { recursive: true });
+  }
   const name = await te({
     message: "Agent name",
     placeholder: "e.g. reviewer, planner, researcher",
@@ -1537,162 +1646,566 @@ async function addAgent(agentPath) {
       if (!/^[a-z][a-z0-9-]*$/.test(value)) {
         return "Use lowercase letters, numbers, and hyphens only";
       }
+      if (existsSync(join(agentPath, `${value}.md`))) {
+        return "Agent already exists";
+      }
+      return;
     }
   });
   if (lD(name)) {
     ue("Cancelled");
     return;
   }
-  const agentType = await ie({
-    message: "Agent type",
+  const description = await te({
+    message: "Description (what does this agent do?)",
+    placeholder: "Reviews code for security issues and best practices",
+    validate: (value) => {
+      if (!value)
+        return "Description is required";
+      return;
+    }
+  });
+  if (lD(description)) {
+    ue("Cancelled");
+    return;
+  }
+  const mode = await ie({
+    message: "Agent mode",
     options: [
-      { value: "primary", label: "Primary agent" },
-      { value: "subagent", label: "Subagent" }
+      {
+        value: "subagent",
+        label: "subagent",
+        hint: "Invoked by primary agents via Task tool"
+      },
+      {
+        value: "primary",
+        label: "primary",
+        hint: "Main agent that orchestrates work"
+      },
+      {
+        value: "all",
+        label: "all",
+        hint: "Can be used in both modes"
+      }
     ]
   });
-  if (lD(agentType)) {
+  if (lD(mode)) {
     ue("Cancelled");
     return;
   }
-  if (!existsSync(agentPath)) {
-    mkdirSync(agentPath, { recursive: true });
-  }
-  const agentFile = join(agentPath, `${name}.md`);
-  if (existsSync(agentFile)) {
-    alreadyExists("Agent", String(name));
-    $e(import_picocolors4.default.red("Failed"));
+  const toolsInput = await te({
+    message: "Tools this agent can use (comma-separated, or empty for all)",
+    placeholder: "read, glob, grep, bash"
+  });
+  if (lD(toolsInput)) {
+    ue("Cancelled");
     return;
   }
-  const content = AGENT_TEMPLATE.replace("{{NAME}}", String(name).charAt(0).toUpperCase() + String(name).slice(1));
-  writeFileSync(agentFile, content);
+  const tools = toolsInput ? String(toolsInput).split(",").map((t) => t.trim()).filter(Boolean) : [];
+  const frontmatterLines = [`mode: ${mode}`, `description: "${description}"`];
+  if (tools.length > 0) {
+    frontmatterLines.push(`tools: [${tools.map((t) => `"${t}"`).join(", ")}]`);
+  }
+  const displayName = String(name).split("-").map((w3) => w3.charAt(0).toUpperCase() + w3.slice(1)).join(" ");
+  const template = `---
+${frontmatterLines.join(`
+`)}
+---
+
+# ${displayName} Agent
+
+${description}
+
+## Role
+
+Describe the specific role and responsibilities of this agent.
+
+## Capabilities
+
+- Capability 1
+- Capability 2
+- Capability 3
+
+## Instructions
+
+Provide specific instructions for how this agent should behave:
+
+1. First, understand the context
+2. Then, analyze the problem
+3. Finally, provide a solution
+
+## Constraints
+
+- What this agent should NOT do
+- Boundaries and limitations
+
+## Output Format
+
+Describe the expected output format for this agent.
+`;
+  const agentFile = join(agentPath, `${name}.md`);
+  writeFileSync(agentFile, template);
   f2.success(`Created ${import_picocolors4.default.cyan(`.opencode/agent/${name}.md`)}`);
-  if (agentType === "primary") {
+  if (mode === "primary") {
     le(`Add to opencode.json:
 
-"agents": {
+"agent": {
   "${name}": {
-    "model": "...",
-    "systemPrompt": ".opencode/agent/${name}.md"
+    "model": "claude-sonnet-4-20250514"
   }
-}`, "Next step");
+}`, "Configure model (optional)");
   }
   $e(import_picocolors4.default.green("Done! Edit the file to customize."));
 }
-async function viewAgent(agentPath, agentName) {
+async function viewAgent(agentPath, agentNameArg) {
+  const agents = collectAgents(agentPath);
+  if (agents.length === 0) {
+    showEmpty("agents", "ock agent create");
+    return;
+  }
+  let agentName = agentNameArg;
   if (!agentName) {
-    if (!existsSync(agentPath)) {
-      showEmpty("agents", "ock agent add");
-      return;
-    }
-    const entries = readdirSync(agentPath);
-    const agents = entries.filter((entry) => {
-      const entryPath = join(agentPath, entry);
-      return lstatSync(entryPath).isFile() && entry.endsWith(".md");
-    }).map((file) => file.replace(".md", ""));
-    if (agents.length === 0) {
-      showEmpty("agents", "ock agent add");
-      return;
-    }
+    const options = agents.map((a3) => ({
+      value: a3.name,
+      label: a3.name,
+      hint: a3.frontmatter.description || ""
+    }));
     const selected = await ie({
       message: "Select agent to view",
-      options: agents.map((a3) => ({ value: a3, label: a3 }))
+      options
     });
     if (lD(selected)) {
       return;
     }
     agentName = selected;
   }
-  const agentFile = join(agentPath, `${agentName}.md`);
-  if (!existsSync(agentFile)) {
+  const agent = agents.find((a3) => a3.name === agentName);
+  if (!agent) {
     notFound("Agent", agentName);
     return;
   }
-  const content = readFileSync(agentFile, "utf-8");
+  const content = readFileSync(agent.path, "utf-8");
   console.log();
-  console.log(import_picocolors4.default.dim("─".repeat(40)));
+  console.log(import_picocolors4.default.dim("─".repeat(60)));
   console.log(content);
-  console.log(import_picocolors4.default.dim("─".repeat(40)));
+  console.log(import_picocolors4.default.dim("─".repeat(60)));
+}
+async function removeAgent(agentPath, agentNameArg) {
+  const agents = collectAgents(agentPath);
+  if (agents.length === 0) {
+    showEmpty("agents", "ock agent create");
+    return;
+  }
+  let agentName = agentNameArg;
+  if (!agentName) {
+    const options = agents.map((a3) => ({
+      value: a3.name,
+      label: a3.name,
+      hint: a3.frontmatter.description || ""
+    }));
+    const selected = await ie({
+      message: "Select agent to remove",
+      options
+    });
+    if (lD(selected)) {
+      return;
+    }
+    agentName = selected;
+  }
+  const agent = agents.find((a3) => a3.name === agentName);
+  if (!agent) {
+    notFound("Agent", agentName);
+    return;
+  }
+  const confirm = await se({
+    message: `Remove agent "${agent.name}"?`,
+    initialValue: false
+  });
+  if (lD(confirm) || !confirm) {
+    ue("Cancelled");
+    return;
+  }
+  unlinkSync(agent.path);
+  f2.success(`Removed agent "${agent.name}"`);
+  const opencodePath = join(process.cwd(), ".opencode");
+  const configPath = join(opencodePath, "opencode.json");
+  if (existsSync(configPath)) {
+    try {
+      const configContent = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      if (config.agent?.[agent.name]) {
+        f2.warn(import_picocolors4.default.yellow(`Note: Agent "${agent.name}" is still configured in opencode.json`));
+      }
+    } catch {}
+  }
 }
 
-// src/commands/completion.ts
+// src/commands/command.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { basename, join as join2 } from "node:path";
 var import_picocolors5 = __toESM(require_picocolors(), 1);
-var BASH_COMPLETION = `# ock bash completion
-_ock_completion() {
-    local cur prev commands
-    COMPREPLY=()
-    cur="\${COMP_WORDS[COMP_CWORD]}"
-    prev="\${COMP_WORDS[COMP_CWORD-1]}"
-    
-    commands="init config upgrade agent skill doctor status help"
-    
-    case "\${prev}" in
-        ock)
-            COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
-            return 0
-            ;;
-        agent)
-            COMPREPLY=( $(compgen -W "list add view" -- "\${cur}") )
-            return 0
-            ;;
-        skill)
-            COMPREPLY=( $(compgen -W "list add view" -- "\${cur}") )
-            return 0
-            ;;
-        config)
-            COMPREPLY=( $(compgen -W "model mcp permission keybinds show" -- "\${cur}") )
-            return 0
-            ;;
-        init)
-            COMPREPLY=( $(compgen -W "--force" -- "\${cur}") )
-            return 0
-            ;;
-        upgrade)
-            COMPREPLY=( $(compgen -W "--force --check" -- "\${cur}") )
-            return 0
-            ;;
-        *)
-            ;;
-    esac
+async function commandCommand(action) {
+  const opencodePath = join2(process.cwd(), ".opencode");
+  if (!existsSync2(opencodePath)) {
+    notInitialized();
+    return;
+  }
+  const commandDir = join2(opencodePath, "command");
+  switch (action) {
+    case "list":
+      listCommands(commandDir);
+      break;
+    case "create":
+      await createCommand(commandDir);
+      break;
+    case "view": {
+      const cmdName = process.argv[4];
+      await viewCommand(commandDir, cmdName);
+      break;
+    }
+    case "remove": {
+      const cmdName = process.argv[4];
+      await removeCommand(commandDir, cmdName);
+      break;
+    }
+    default:
+      unknownAction(action, ["list", "create", "view", "remove"]);
+  }
 }
-complete -F _ock_completion ock
-`;
-var ZSH_COMPLETION = `#compdef ock
-
-_ock() {
-    local -a commands
-    local -a agent_actions
-    local -a skill_actions
-    local -a config_actions
-    
-    commands=(
-        'init:Initialize OpenCodeKit in current directory'
-        'config:Edit opencode.json'
-        'upgrade:Update templates to latest version'
-        'agent:Manage agents'
-        'skill:Manage skills'
-        'doctor:Check project health'
-        'status:Show project overview'
-        'help:Show help'
-    )
-    
-    agent_actions=(
-        'list:List all agents'
-        'add:Create a new agent'
-        'view:View agent details'
-    )
-    
-    skill_actions=(
-        'list:List all skills'
-        'add:Install a skill'
-        'view:View skill details'
-    )
-    
-    config_actions=(
-        'model:Change default model'
-        'mcp:Manage MCP servers'
-        'permission:Edit permissions'
-        'keybinds:Edit keyboard shortcuts'
-        'show:View current config'
+function parseFrontmatter2(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const frontmatter = {};
+  const lines = match[1].split(`
+`);
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (value === "true")
+        value = true;
+      if (value === "false")
+        value = false;
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body: match[2] };
+}
+function listCommands(commandDir) {
+  if (!existsSync2(commandDir)) {
+    showEmpty("slash commands", "ock command create");
+    return;
+  }
+  const files = readdirSync2(commandDir).filter((f3) => f3.endsWith(".md"));
+  if (files.length === 0) {
+    showEmpty("slash commands", "ock command create");
+    return;
+  }
+  f2.info(import_picocolors5.default.bold("Slash Commands"));
+  for (const file of files.sort()) {
+    const name = basename(file, ".md");
+    const content = readFileSync2(join2(commandDir, file), "utf-8");
+    const { frontmatter } = parseFrontmatter2(content);
+    const agent = frontmatter.agent ? import_picocolors5.default.dim(`[${frontmatter.agent}]`) : import_picocolors5.default.dim("[build]");
+    const desc = frontmatter.description ? import_picocolors5.default.dim(` - ${frontmatter.description}`) : "";
+    const hint = frontmatter["argument-hint"] ? import_picocolors5.default.yellow(` ${frontmatter["argument-hint"]}`) : "";
+    const subtask = frontmatter.subtask ? import_picocolors5.default.magenta(" (subtask)") : "";
+    console.log(`  ${import_picocolors5.default.cyan(`/${name}`)}${hint}${subtask} ${agent}${desc}`);
+  }
+  console.log();
+  f2.info(import_picocolors5.default.dim(`Found ${files.length} command${files.length === 1 ? "" : "s"}`));
+}
+async function createCommand(commandDir) {
+  oe(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" Create Slash Command ")));
+  if (!existsSync2(commandDir)) {
+    mkdirSync2(commandDir, { recursive: true });
+  }
+  const name = await te({
+    message: "Command name (without /)",
+    placeholder: "my-command",
+    validate: (value) => {
+      if (!value)
+        return "Name is required";
+      if (!/^[a-z][a-z0-9-]*$/.test(value)) {
+        return "Use lowercase letters, numbers, and hyphens only";
+      }
+      if (existsSync2(join2(commandDir, `${value}.md`))) {
+        return "Command already exists";
+      }
+      return;
+    }
+  });
+  if (lD(name)) {
+    ue("Cancelled");
+    return;
+  }
+  const description = await te({
+    message: "Description",
+    placeholder: "What does this command do?"
+  });
+  if (lD(description)) {
+    ue("Cancelled");
+    return;
+  }
+  const agent = await ie({
+    message: "Which agent runs this command?",
+    options: [
+      { value: "build", label: "build", hint: "Implementation work" },
+      { value: "planner", label: "planner", hint: "Architecture & design" },
+      { value: "scout", label: "scout", hint: "External research" },
+      { value: "explore", label: "explore", hint: "Codebase search" },
+      { value: "review", label: "review", hint: "Code review & debugging" },
+      { value: "vision", label: "vision", hint: "UI/UX & visual analysis" }
+    ]
+  });
+  if (lD(agent)) {
+    ue("Cancelled");
+    return;
+  }
+  const argumentHint = await te({
+    message: "Argument hint (optional)",
+    placeholder: "<required> [optional]"
+  });
+  if (lD(argumentHint)) {
+    ue("Cancelled");
+    return;
+  }
+  const isSubtask = await se({
+    message: "Run as subtask? (doesn't pollute primary context)",
+    initialValue: false
+  });
+  if (lD(isSubtask)) {
+    ue("Cancelled");
+    return;
+  }
+  const frontmatterLines = [`description: "${description}"`];
+  if (argumentHint) {
+    frontmatterLines.push(`argument-hint: "${argumentHint}"`);
+  }
+  frontmatterLines.push(`agent: ${agent}`);
+  if (isSubtask) {
+    frontmatterLines.push("subtask: true");
+  }
+  const template = `---
+${frontmatterLines.join(`
+`)}
+---
+
+# ${String(name).charAt(0).toUpperCase() + String(name).slice(1).replace(/-/g, " ")}: $ARGUMENTS
+
+${description}
+
+## Context
+
+\`\`\`typescript
+// Load any required skills
+// skill({ name: "example" });
+\`\`\`
+
+## Instructions
+
+<!-- Add your command instructions here -->
+
+1. Step one
+2. Step two
+3. Step three
+
+## Output
+
+<!-- Define expected output format -->
+`;
+  const filePath = join2(commandDir, `${name}.md`);
+  writeFileSync2(filePath, template);
+  $e(import_picocolors5.default.green(`Created /${name} at .opencode/command/${name}.md`));
+}
+async function viewCommand(commandDir, cmdNameArg) {
+  if (!existsSync2(commandDir)) {
+    showEmpty("slash commands", "ock command create");
+    return;
+  }
+  const files = readdirSync2(commandDir).filter((f3) => f3.endsWith(".md"));
+  if (files.length === 0) {
+    showEmpty("slash commands", "ock command create");
+    return;
+  }
+  let cmdName = cmdNameArg;
+  if (!cmdName) {
+    const options = files.sort().map((f3) => {
+      const name = basename(f3, ".md");
+      const content2 = readFileSync2(join2(commandDir, f3), "utf-8");
+      const { frontmatter } = parseFrontmatter2(content2);
+      return {
+        value: name,
+        label: `/${name}`,
+        hint: frontmatter.description || ""
+      };
+    });
+    const selected = await ie({
+      message: "Select command to view",
+      options
+    });
+    if (lD(selected)) {
+      return;
+    }
+    cmdName = selected;
+  }
+  if (cmdName.startsWith("/")) {
+    cmdName = cmdName.slice(1);
+  }
+  const filePath = join2(commandDir, `${cmdName}.md`);
+  if (!existsSync2(filePath)) {
+    f2.error(`Command /${cmdName} not found`);
+    return;
+  }
+  const content = readFileSync2(filePath, "utf-8");
+  console.log();
+  console.log(import_picocolors5.default.dim("─".repeat(60)));
+  console.log(content);
+  console.log(import_picocolors5.default.dim("─".repeat(60)));
+}
+async function removeCommand(commandDir, cmdNameArg) {
+  if (!existsSync2(commandDir)) {
+    showEmpty("slash commands", "ock command create");
+    return;
+  }
+  const files = readdirSync2(commandDir).filter((f3) => f3.endsWith(".md"));
+  if (files.length === 0) {
+    showEmpty("slash commands", "ock command create");
+    return;
+  }
+  let cmdName = cmdNameArg;
+  if (!cmdName) {
+    const options = files.sort().map((f3) => {
+      const name = basename(f3, ".md");
+      const content = readFileSync2(join2(commandDir, f3), "utf-8");
+      const { frontmatter } = parseFrontmatter2(content);
+      return {
+        value: name,
+        label: `/${name}`,
+        hint: frontmatter.description || ""
+      };
+    });
+    const selected = await ie({
+      message: "Select command to remove",
+      options
+    });
+    if (lD(selected)) {
+      return;
+    }
+    cmdName = selected;
+  }
+  if (cmdName.startsWith("/")) {
+    cmdName = cmdName.slice(1);
+  }
+  const filePath = join2(commandDir, `${cmdName}.md`);
+  if (!existsSync2(filePath)) {
+    f2.error(`Command /${cmdName} not found`);
+    return;
+  }
+  const confirm = await se({
+    message: `Remove /${cmdName}?`,
+    initialValue: false
+  });
+  if (lD(confirm) || !confirm) {
+    ue("Cancelled");
+    return;
+  }
+  unlinkSync2(filePath);
+  f2.success(`Removed /${cmdName}`);
+}
+
+// src/commands/completion.ts
+var import_picocolors6 = __toESM(require_picocolors(), 1);
+var BASH_COMPLETION = `# ock bash completion
+_ock_completion() {
+    local cur prev commands
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    
+    commands="init config upgrade agent skill doctor status help"
+    
+    case "\${prev}" in
+        ock)
+            COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+            return 0
+            ;;
+        agent)
+            COMPREPLY=( $(compgen -W "list add view" -- "\${cur}") )
+            return 0
+            ;;
+        skill)
+            COMPREPLY=( $(compgen -W "list add view" -- "\${cur}") )
+            return 0
+            ;;
+        config)
+            COMPREPLY=( $(compgen -W "model mcp permission keybinds show" -- "\${cur}") )
+            return 0
+            ;;
+        init)
+            COMPREPLY=( $(compgen -W "--force" -- "\${cur}") )
+            return 0
+            ;;
+        upgrade)
+            COMPREPLY=( $(compgen -W "--force --check" -- "\${cur}") )
+            return 0
+            ;;
+        *)
+            ;;
+    esac
+}
+complete -F _ock_completion ock
+`;
+var ZSH_COMPLETION = `#compdef ock
+
+_ock() {
+    local -a commands
+    local -a agent_actions
+    local -a skill_actions
+    local -a config_actions
+    
+    commands=(
+        'init:Initialize OpenCodeKit in current directory'
+        'config:Edit opencode.json'
+        'upgrade:Update templates to latest version'
+        'agent:Manage agents'
+        'skill:Manage skills'
+        'doctor:Check project health'
+        'status:Show project overview'
+        'help:Show help'
+    )
+    
+    agent_actions=(
+        'list:List all agents'
+        'add:Create a new agent'
+        'view:View agent details'
+    )
+    
+    skill_actions=(
+        'list:List all skills'
+        'add:Install a skill'
+        'view:View skill details'
+    )
+    
+    config_actions=(
+        'model:Change default model'
+        'mcp:Manage MCP servers'
+        'permission:Edit permissions'
+        'keybinds:Edit keyboard shortcuts'
+        'show:View current config'
     )
     
     case "$words[2]" in
@@ -1755,8 +2268,9 @@ complete -c ock -n "__fish_seen_subcommand_from upgrade" -l force -d "Force upgr
 complete -c ock -n "__fish_seen_subcommand_from upgrade" -l check -d "Check only"
 `;
 async function completionCommand(shell) {
-  if (!shell) {
-    oe(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" Shell Completion ")));
+  let selectedShell = shell;
+  if (!selectedShell) {
+    oe(import_picocolors6.default.bgCyan(import_picocolors6.default.black(" Shell Completion ")));
     const selected = await ie({
       message: "Select your shell",
       options: [
@@ -1769,11 +2283,11 @@ async function completionCommand(shell) {
       ue("Cancelled");
       return;
     }
-    shell = selected;
+    selectedShell = selected;
   }
   let script;
   let setupInstructions;
-  switch (shell) {
+  switch (selectedShell) {
     case "bash":
       script = BASH_COMPLETION;
       setupInstructions = `Add to ~/.bashrc:
@@ -1802,14 +2316,14 @@ Or save to fpath:
   }
   console.log(script);
   console.error();
-  console.error(import_picocolors5.default.bold("Setup:"));
-  console.error(import_picocolors5.default.dim(setupInstructions));
+  console.error(import_picocolors6.default.bold("Setup:"));
+  console.error(import_picocolors6.default.dim(setupInstructions));
 }
 
 // src/commands/config.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-var import_picocolors6 = __toESM(require_picocolors(), 1);
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+var import_picocolors7 = __toESM(require_picocolors(), 1);
 var DEFAULT_SERVER_PORT = 4096;
 var MODELS_DEV_URL = "https://models.dev/api.json";
 async function fetchFromServer(endpoint) {
@@ -1839,13 +2353,13 @@ async function getAgentsFromServer() {
   return fetchFromServer("/agent");
 }
 async function configCommand(action) {
-  const opencodePath = join2(process.cwd(), ".opencode");
-  const configPath = join2(opencodePath, "opencode.json");
-  if (!existsSync2(opencodePath)) {
+  const opencodePath = join3(process.cwd(), ".opencode");
+  const configPath = join3(opencodePath, "opencode.json");
+  if (!existsSync3(opencodePath)) {
     notInitialized();
     return;
   }
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     showError("opencode.json not found", "ock init --force");
     return;
   }
@@ -1884,6 +2398,9 @@ async function configCommand(action) {
     case "show":
       showConfig(configPath);
       break;
+    case "validate":
+      await validateConfig(configPath);
+      break;
     default:
       unknownAction(action, [
         "model",
@@ -1895,71 +2412,255 @@ async function configCommand(action) {
         "tools",
         "share",
         "autoupdate",
-        "show"
+        "show",
+        "validate"
       ]);
   }
 }
 function loadConfig(configPath) {
-  const content = readFileSync2(configPath, "utf-8");
+  const content = readFileSync3(configPath, "utf-8");
   const jsonWithoutComments = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
   return JSON.parse(jsonWithoutComments);
 }
 function saveConfig(configPath, config) {
-  writeFileSync2(configPath, JSON.stringify(config, null, 2) + `
+  writeFileSync3(configPath, `${JSON.stringify(config, null, 2)}
 `);
 }
+var OPENCODE_SCHEMA_URL = "https://opencode.ai/config.json";
+var KNOWN_PROPERTIES = new Set([
+  "$schema",
+  "model",
+  "small_model",
+  "theme",
+  "share",
+  "autoupdate",
+  "mcp",
+  "permission",
+  "keybinds",
+  "provider",
+  "agent",
+  "formatter",
+  "plugin",
+  "tools",
+  "tui",
+  "command",
+  "watcher",
+  "snapshot",
+  "disabled_providers",
+  "enabled_providers",
+  "username",
+  "lsp",
+  "instructions",
+  "enterprise",
+  "experimental",
+  "compaction"
+]);
+async function validateConfig(configPath) {
+  oe(import_picocolors7.default.bgBlue(import_picocolors7.default.white(" Validate Configuration ")));
+  const issues = [];
+  let config;
+  try {
+    config = loadConfig(configPath);
+    f2.success("Valid JSON syntax");
+  } catch (err) {
+    f2.error(`Invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    $e(import_picocolors7.default.red("Validation failed"));
+    return;
+  }
+  if (!config.$schema) {
+    issues.push({
+      type: "warning",
+      path: "$schema",
+      message: 'Missing $schema reference. Add: "$schema": "https://opencode.ai/config.json"'
+    });
+  } else if (!config.$schema.includes("opencode.ai")) {
+    issues.push({
+      type: "warning",
+      path: "$schema",
+      message: `Unexpected schema URL: ${config.$schema}`
+    });
+  }
+  for (const key of Object.keys(config)) {
+    if (!KNOWN_PROPERTIES.has(key)) {
+      issues.push({
+        type: "warning",
+        path: key,
+        message: `Unknown property "${key}" - may be ignored by OpenCode`
+      });
+    }
+  }
+  if (config.model !== undefined && typeof config.model !== "string") {
+    issues.push({
+      type: "error",
+      path: "model",
+      message: "model must be a string"
+    });
+  }
+  if (config.theme !== undefined && typeof config.theme !== "string") {
+    issues.push({
+      type: "error",
+      path: "theme",
+      message: "theme must be a string"
+    });
+  }
+  if (config.share !== undefined) {
+    const validShare = ["manual", "auto", "disabled"];
+    if (!validShare.includes(config.share)) {
+      issues.push({
+        type: "error",
+        path: "share",
+        message: `share must be one of: ${validShare.join(", ")}`
+      });
+    }
+  }
+  if (config.autoupdate !== undefined) {
+    if (typeof config.autoupdate !== "boolean" && config.autoupdate !== "notify") {
+      issues.push({
+        type: "error",
+        path: "autoupdate",
+        message: 'autoupdate must be boolean or "notify"'
+      });
+    }
+  }
+  if (config.plugin !== undefined && !Array.isArray(config.plugin)) {
+    issues.push({
+      type: "error",
+      path: "plugin",
+      message: "plugin must be an array of strings"
+    });
+  }
+  if (config.instructions !== undefined && !Array.isArray(config.instructions)) {
+    issues.push({
+      type: "error",
+      path: "instructions",
+      message: "instructions must be an array of strings"
+    });
+  }
+  if (config.mcp) {
+    for (const [name, server] of Object.entries(config.mcp)) {
+      if (!server.command && !server.url) {
+        issues.push({
+          type: "error",
+          path: `mcp.${name}`,
+          message: "MCP server must have either 'command' or 'url'"
+        });
+      }
+      if (server.command && !Array.isArray(server.command)) {
+        issues.push({
+          type: "error",
+          path: `mcp.${name}.command`,
+          message: "command must be an array of strings"
+        });
+      }
+    }
+  }
+  if (config.agent) {
+    for (const [name, agent] of Object.entries(config.agent)) {
+      if (agent.mode !== undefined) {
+        const validModes = ["subagent", "primary", "all"];
+        if (!validModes.includes(agent.mode)) {
+          issues.push({
+            type: "error",
+            path: `agent.${name}.mode`,
+            message: `mode must be one of: ${validModes.join(", ")}`
+          });
+        }
+      }
+      if (agent.temperature !== undefined) {
+        if (typeof agent.temperature !== "number" || agent.temperature < 0 || agent.temperature > 2) {
+          issues.push({
+            type: "warning",
+            path: `agent.${name}.temperature`,
+            message: "temperature should be a number between 0 and 2"
+          });
+        }
+      }
+    }
+  }
+  try {
+    const response = await fetch(OPENCODE_SCHEMA_URL);
+    if (response.ok) {
+      f2.success("Schema fetched from opencode.ai");
+    }
+  } catch {
+    f2.warn("Could not fetch schema from opencode.ai (offline?)");
+  }
+  const errors = issues.filter((i) => i.type === "error");
+  const warnings = issues.filter((i) => i.type === "warning");
+  if (errors.length > 0) {
+    console.log();
+    f2.error(import_picocolors7.default.bold(`${errors.length} error${errors.length === 1 ? "" : "s"}`));
+    for (const issue of errors) {
+      console.log(`  ${import_picocolors7.default.red("✗")} ${import_picocolors7.default.yellow(issue.path)}: ${issue.message}`);
+    }
+  }
+  if (warnings.length > 0) {
+    console.log();
+    f2.warn(import_picocolors7.default.bold(`${warnings.length} warning${warnings.length === 1 ? "" : "s"}`));
+    for (const issue of warnings) {
+      console.log(`  ${import_picocolors7.default.yellow("!")} ${import_picocolors7.default.dim(issue.path)}: ${issue.message}`);
+    }
+  }
+  if (issues.length === 0) {
+    $e(import_picocolors7.default.green("Configuration is valid!"));
+  } else if (errors.length > 0) {
+    $e(import_picocolors7.default.red(`Validation failed with ${errors.length} error${errors.length === 1 ? "" : "s"}`));
+  } else {
+    $e(import_picocolors7.default.yellow(`Valid with ${warnings.length} warning${warnings.length === 1 ? "" : "s"}`));
+  }
+}
 function showConfig(configPath) {
   const config = loadConfig(configPath);
   console.log();
-  console.log(import_picocolors6.default.bold("  Model"));
-  console.log(`    ${import_picocolors6.default.cyan(config.model || "not set")}`);
+  console.log(import_picocolors7.default.bold("  Model"));
+  console.log(`    ${import_picocolors7.default.cyan(config.model || "not set")}`);
   if (config.small_model) {
-    console.log(import_picocolors6.default.bold("  Small Model"));
-    console.log(`    ${import_picocolors6.default.cyan(config.small_model)}`);
+    console.log(import_picocolors7.default.bold("  Small Model"));
+    console.log(`    ${import_picocolors7.default.cyan(config.small_model)}`);
   }
-  console.log(import_picocolors6.default.bold("  Theme"));
-  console.log(`    ${import_picocolors6.default.cyan(config.theme || "system")}`);
-  console.log(import_picocolors6.default.bold("  Share"));
-  console.log(`    ${import_picocolors6.default.cyan(config.share || "manual")}`);
+  console.log(import_picocolors7.default.bold("  Theme"));
+  console.log(`    ${import_picocolors7.default.cyan(config.theme || "system")}`);
+  console.log(import_picocolors7.default.bold("  Share"));
+  console.log(`    ${import_picocolors7.default.cyan(config.share || "manual")}`);
   const autoupdateDisplay = config.autoupdate === "notify" ? "notify" : config.autoupdate === false ? "disabled" : "enabled";
-  console.log(import_picocolors6.default.bold("  Autoupdate"));
-  console.log(`    ${import_picocolors6.default.cyan(autoupdateDisplay)}`);
+  console.log(import_picocolors7.default.bold("  Autoupdate"));
+  console.log(`    ${import_picocolors7.default.cyan(autoupdateDisplay)}`);
   if (config.tui && Object.keys(config.tui).length > 0) {
-    console.log(import_picocolors6.default.bold("  TUI"));
+    console.log(import_picocolors7.default.bold("  TUI"));
     if (config.tui.scroll_speed !== undefined) {
-      console.log(`    scroll_speed: ${import_picocolors6.default.cyan(String(config.tui.scroll_speed))}`);
+      console.log(`    scroll_speed: ${import_picocolors7.default.cyan(String(config.tui.scroll_speed))}`);
     }
     if (config.tui.scroll_acceleration !== undefined) {
-      console.log(`    scroll_acceleration: ${import_picocolors6.default.cyan(String(config.tui.scroll_acceleration))}`);
+      console.log(`    scroll_acceleration: ${import_picocolors7.default.cyan(String(config.tui.scroll_acceleration))}`);
     }
     if (config.tui.diff_style) {
-      console.log(`    diff_style: ${import_picocolors6.default.cyan(config.tui.diff_style)}`);
+      console.log(`    diff_style: ${import_picocolors7.default.cyan(config.tui.diff_style)}`);
     }
   }
   if (config.mcp && Object.keys(config.mcp).length > 0) {
-    console.log(import_picocolors6.default.bold("  MCP Servers"));
+    console.log(import_picocolors7.default.bold("  MCP Servers"));
     for (const [name, server] of Object.entries(config.mcp)) {
-      const status = server.enabled === false ? import_picocolors6.default.dim("off") : import_picocolors6.default.green("on");
+      const status = server.enabled === false ? import_picocolors7.default.dim("off") : import_picocolors7.default.green("on");
       console.log(`    ${status} ${name}`);
     }
   }
   if (config.tools && Object.keys(config.tools).length > 0) {
-    console.log(import_picocolors6.default.bold("  Tools"));
+    console.log(import_picocolors7.default.bold("  Tools"));
     for (const [tool, enabled] of Object.entries(config.tools)) {
-      const status = enabled === false ? import_picocolors6.default.red("off") : import_picocolors6.default.green("on");
+      const status = enabled === false ? import_picocolors7.default.red("off") : import_picocolors7.default.green("on");
       console.log(`    ${status} ${tool}`);
     }
   }
   if (config.keybinds && Object.keys(config.keybinds).length > 0) {
-    console.log(import_picocolors6.default.bold("  Keybinds"));
+    console.log(import_picocolors7.default.bold("  Keybinds"));
     for (const [action, key] of Object.entries(config.keybinds)) {
-      console.log(`    ${import_picocolors6.default.dim(action)}: ${import_picocolors6.default.cyan(key)}`);
+      console.log(`    ${import_picocolors7.default.dim(action)}: ${import_picocolors7.default.cyan(key)}`);
     }
   }
   console.log();
 }
 async function configMenu(configPath) {
-  oe(import_picocolors6.default.bgCyan(import_picocolors6.default.black(" Configuration ")));
+  oe(import_picocolors7.default.bgCyan(import_picocolors7.default.black(" Configuration ")));
   while (true) {
     const action = await ie({
       message: "What do you want to configure?",
@@ -2034,8 +2735,8 @@ async function editModel(configPath, modelType = "model") {
   const config = loadConfig(configPath);
   const currentModel = config[modelType] || "not set";
   const modelLabel = modelType === "small_model" ? "Small Model" : "Model";
-  f2.info(`Current ${modelLabel}: ${import_picocolors6.default.cyan(currentModel)}`);
-  f2.info(import_picocolors6.default.dim("Fetching models from models.dev..."));
+  f2.info(`Current ${modelLabel}: ${import_picocolors7.default.cyan(currentModel)}`);
+  f2.info(import_picocolors7.default.dim("Fetching models from models.dev..."));
   const modelsDevData = await fetchFromModelsDev();
   if (!modelsDevData || Object.keys(modelsDevData).length === 0) {
     f2.warn("models.dev unavailable - please enter manually");
@@ -2056,7 +2757,7 @@ async function editModel(configPath, modelType = "model") {
     }
     config[modelType] = newModel;
     saveConfig(configPath, config);
-    f2.success(`${modelLabel} set to ${import_picocolors6.default.cyan(newModel)}`);
+    f2.success(`${modelLabel} set to ${import_picocolors7.default.cyan(newModel)}`);
     return;
   }
   f2.success("Fetched models from models.dev");
@@ -2119,7 +2820,7 @@ async function editModel(configPath, modelType = "model") {
     }
     config[modelType] = customModel;
     saveConfig(configPath, config);
-    f2.success(`${modelLabel} set to ${import_picocolors6.default.cyan(customModel)}`);
+    f2.success(`${modelLabel} set to ${import_picocolors7.default.cyan(customModel)}`);
     return;
   }
   if (providerId === "__search__") {
@@ -2184,7 +2885,7 @@ async function editModel(configPath, modelType = "model") {
   const fullModelId = `${providerId}/${selectedModel}`;
   config[modelType] = fullModelId;
   saveConfig(configPath, config);
-  f2.success(`${modelLabel} set to ${import_picocolors6.default.cyan(fullModelId)}`);
+  f2.success(`${modelLabel} set to ${import_picocolors7.default.cyan(fullModelId)}`);
 }
 function getModelsForProvider(provider) {
   const options = [];
@@ -2232,7 +2933,7 @@ async function editAgentModel(configPath) {
   let agentNames = [];
   const agentInfoMap = new Map;
   if (serverAgents && serverAgents.length > 0) {
-    f2.info(import_picocolors6.default.dim("Fetched agents from OpenCode server"));
+    f2.info(import_picocolors7.default.dim("Fetched agents from OpenCode server"));
     for (const agent of serverAgents) {
       agentNames.push(agent.name);
       agentInfoMap.set(agent.name, {
@@ -2256,14 +2957,14 @@ async function editAgentModel(configPath) {
     return;
   }
   console.log();
-  console.log(import_picocolors6.default.bold("  Agent Models"));
+  console.log(import_picocolors7.default.bold("  Agent Models"));
   for (const name of agentNames) {
     const info = agentInfoMap.get(name);
-    const model = info?.model || import_picocolors6.default.dim("(default)");
-    const builtIn = info?.builtIn ? import_picocolors6.default.dim(" [built-in]") : "";
+    const model = info?.model || import_picocolors7.default.dim("(default)");
+    const builtIn = info?.builtIn ? import_picocolors7.default.dim(" [built-in]") : "";
     const localConfig = config.agent[name];
-    const disabled = localConfig?.disable ? import_picocolors6.default.red(" [disabled]") : "";
-    console.log(`    ${import_picocolors6.default.cyan(name)}: ${model}${builtIn}${disabled}`);
+    const disabled = localConfig?.disable ? import_picocolors7.default.red(" [disabled]") : "";
+    console.log(`    ${import_picocolors7.default.cyan(name)}: ${model}${builtIn}${disabled}`);
   }
   console.log();
   const agentOptions = [
@@ -2311,7 +3012,7 @@ async function editAgentModel(configPath) {
     }
     config.agent[agentName].disable = !currentAgent.disable;
     saveConfig(configPath, config);
-    const status = config.agent[agentName].disable ? import_picocolors6.default.red("disabled") : import_picocolors6.default.green("enabled");
+    const status = config.agent[agentName].disable ? import_picocolors7.default.red("disabled") : import_picocolors7.default.green("enabled");
     f2.success(`Agent ${agentName}: ${status}`);
     return;
   }
@@ -2332,8 +3033,8 @@ async function editAgentModel(configPath) {
     return;
   }
   const agentInfo = agentInfoMap.get(agentName);
-  f2.info(`Current model: ${import_picocolors6.default.cyan(agentInfo?.model || currentAgent.model || "(default)")}`);
-  f2.info(import_picocolors6.default.dim("Fetching models from models.dev..."));
+  f2.info(`Current model: ${import_picocolors7.default.cyan(agentInfo?.model || currentAgent.model || "(default)")}`);
+  f2.info(import_picocolors7.default.dim("Fetching models from models.dev..."));
   const modelsDevData = await fetchFromModelsDev();
   if (!modelsDevData || Object.keys(modelsDevData).length === 0) {
     f2.warn("models.dev unavailable - please enter manually");
@@ -2355,7 +3056,7 @@ async function editAgentModel(configPath) {
     }
     config.agent[agentName].model = newModel;
     saveConfig(configPath, config);
-    f2.success(`${agentName} model set to ${import_picocolors6.default.cyan(newModel)}`);
+    f2.success(`${agentName} model set to ${import_picocolors7.default.cyan(newModel)}`);
     return;
   }
   const localProviders = config.provider || {};
@@ -2413,7 +3114,7 @@ async function editAgentModel(configPath) {
       agentConfig.model = undefined;
     }
     saveConfig(configPath, config);
-    f2.success(`${agentName} model set to ${import_picocolors6.default.cyan("(default)")}`);
+    f2.success(`${agentName} model set to ${import_picocolors7.default.cyan("(default)")}`);
     return;
   }
   if (providerId === "__custom__") {
@@ -2435,7 +3136,7 @@ async function editAgentModel(configPath) {
     }
     config.agent[agentName].model = customModel;
     saveConfig(configPath, config);
-    f2.success(`${agentName} model set to ${import_picocolors6.default.cyan(customModel)}`);
+    f2.success(`${agentName} model set to ${import_picocolors7.default.cyan(customModel)}`);
     return;
   }
   if (providerId === "__search__") {
@@ -2490,7 +3191,7 @@ async function editAgentModel(configPath) {
   }
   config.agent[agentName].model = fullModelId;
   saveConfig(configPath, config);
-  f2.success(`${agentName} model set to ${import_picocolors6.default.cyan(fullModelId)}`);
+  f2.success(`${agentName} model set to ${import_picocolors7.default.cyan(fullModelId)}`);
 }
 async function editMCP(configPath) {
   const config = loadConfig(configPath);
@@ -2509,11 +3210,11 @@ async function editMCP(configPath) {
     return;
   }
   console.log();
-  console.log(import_picocolors6.default.bold("  MCP Servers"));
+  console.log(import_picocolors7.default.bold("  MCP Servers"));
   for (const [name, server] of Object.entries(config.mcp)) {
-    const status = server.enabled === false ? import_picocolors6.default.red("off") : import_picocolors6.default.green("on");
-    const type = server.type === "remote" ? import_picocolors6.default.dim("remote") : import_picocolors6.default.dim("local");
-    const endpoint = server.type === "remote" ? import_picocolors6.default.dim(` → ${server.url}`) : import_picocolors6.default.dim(` → ${(server.command || []).join(" ")}`);
+    const status = server.enabled === false ? import_picocolors7.default.red("off") : import_picocolors7.default.green("on");
+    const type = server.type === "remote" ? import_picocolors7.default.dim("remote") : import_picocolors7.default.dim("local");
+    const endpoint = server.type === "remote" ? import_picocolors7.default.dim(` → ${server.url}`) : import_picocolors7.default.dim(` → ${(server.command || []).join(" ")}`);
     console.log(`    ${status} ${name} ${type}${endpoint}`);
   }
   console.log();
@@ -2555,11 +3256,15 @@ async function toggleMCP(configPath, config) {
     return;
   }
   const serverName = selected;
-  const server = config.mcp[serverName];
+  const server = config.mcp?.[serverName];
+  if (!server) {
+    f2.error(`Server "${serverName}" not found`);
+    return;
+  }
   const wasEnabled = server.enabled !== false;
   server.enabled = !wasEnabled;
   saveConfig(configPath, config);
-  const status = server.enabled ? import_picocolors6.default.green("enabled") : import_picocolors6.default.dim("disabled");
+  const status = server.enabled ? import_picocolors7.default.green("enabled") : import_picocolors7.default.dim("disabled");
   f2.success(`${serverName}: ${status}`);
 }
 async function addMCPServer(configPath, config) {
@@ -2601,6 +3306,7 @@ async function addMCPServer(configPath, config) {
     if (lD(url)) {
       return;
     }
+    config.mcp = config.mcp ?? {};
     config.mcp[serverName] = {
       type: "remote",
       url,
@@ -2618,6 +3324,7 @@ async function addMCPServer(configPath, config) {
     if (lD(command)) {
       return;
     }
+    config.mcp = config.mcp ?? {};
     config.mcp[serverName] = {
       type: "local",
       command: command.split(" "),
@@ -2625,7 +3332,7 @@ async function addMCPServer(configPath, config) {
     };
   }
   saveConfig(configPath, config);
-  f2.success(`Added MCP server: ${import_picocolors6.default.cyan(serverName)}`);
+  f2.success(`Added MCP server: ${import_picocolors7.default.cyan(serverName)}`);
 }
 async function removeMCP(configPath, config) {
   const servers = Object.keys(config.mcp || {}).map((name) => ({
@@ -2646,7 +3353,7 @@ async function removeMCP(configPath, config) {
   if (lD(confirm) || !confirm) {
     return;
   }
-  delete config.mcp[serverName];
+  delete config.mcp?.[serverName];
   saveConfig(configPath, config);
   f2.success(`Removed: ${serverName}`);
 }
@@ -2656,13 +3363,13 @@ async function editPermissions(configPath) {
     config.permission = {};
   }
   console.log();
-  console.log(import_picocolors6.default.bold("  Current Permissions"));
-  console.log(`    edit: ${import_picocolors6.default.cyan(config.permission.edit || "ask")}`);
-  console.log(`    external_directory: ${import_picocolors6.default.cyan(config.permission.external_directory || "ask")}`);
+  console.log(import_picocolors7.default.bold("  Current Permissions"));
+  console.log(`    edit: ${import_picocolors7.default.cyan(config.permission.edit || "ask")}`);
+  console.log(`    external_directory: ${import_picocolors7.default.cyan(config.permission.external_directory || "ask")}`);
   if (config.permission.bash) {
-    console.log(import_picocolors6.default.bold("  Bash"));
+    console.log(import_picocolors7.default.bold("  Bash"));
     for (const [pattern, perm] of Object.entries(config.permission.bash)) {
-      console.log(`    ${import_picocolors6.default.dim(pattern)}: ${import_picocolors6.default.cyan(perm)}`);
+      console.log(`    ${import_picocolors7.default.dim(pattern)}: ${import_picocolors7.default.cyan(perm)}`);
     }
   }
   console.log();
@@ -2724,9 +3431,9 @@ async function editKeybinds(configPath) {
   }
   if (Object.keys(config.keybinds).length > 0) {
     console.log();
-    console.log(import_picocolors6.default.bold("  Current Keybinds"));
+    console.log(import_picocolors7.default.bold("  Current Keybinds"));
     for (const [action2, key] of Object.entries(config.keybinds)) {
-      console.log(`    ${import_picocolors6.default.dim(action2)}: ${import_picocolors6.default.cyan(key)}`);
+      console.log(`    ${import_picocolors7.default.dim(action2)}: ${import_picocolors7.default.cyan(key)}`);
     }
     console.log();
   }
@@ -2779,7 +3486,7 @@ async function editKeybinds(configPath) {
   }
   config.keybinds[keybindName] = newKey;
   saveConfig(configPath, config);
-  f2.success(`${keybindName} → ${import_picocolors6.default.cyan(newKey)}`);
+  f2.success(`${keybindName} → ${import_picocolors7.default.cyan(newKey)}`);
 }
 var OPENCODE_THEMES = [
   { value: "system", label: "System", hint: "follows OS preference" },
@@ -2819,7 +3526,7 @@ var OPENCODE_THEMES = [
 async function editTheme(configPath) {
   const config = loadConfig(configPath);
   const currentTheme = config.theme || "system";
-  f2.info(`Current theme: ${import_picocolors6.default.cyan(currentTheme)}`);
+  f2.info(`Current theme: ${import_picocolors7.default.cyan(currentTheme)}`);
   const validTheme = OPENCODE_THEMES.some((t) => t.value === currentTheme) ? currentTheme : "system";
   const selectedTheme = await ie({
     message: "Select theme",
@@ -2836,7 +3543,7 @@ async function editTheme(configPath) {
   }
   config.theme = selectedTheme;
   saveConfig(configPath, config);
-  f2.success(`Theme set to ${import_picocolors6.default.cyan(selectedTheme)}`);
+  f2.success(`Theme set to ${import_picocolors7.default.cyan(selectedTheme)}`);
 }
 async function editTui(configPath) {
   const config = loadConfig(configPath);
@@ -2884,7 +3591,7 @@ async function editTui(configPath) {
     }
     config.tui.diff_style = style;
     saveConfig(configPath, config);
-    f2.success(`Diff style set to ${import_picocolors6.default.cyan(style)}`);
+    f2.success(`Diff style set to ${import_picocolors7.default.cyan(style)}`);
   } else {
     const settingKey = setting;
     const value = await te({
@@ -2901,7 +3608,7 @@ async function editTui(configPath) {
     }
     config.tui[settingKey] = value ? Number(value) : undefined;
     saveConfig(configPath, config);
-    f2.success(`${settingKey} set to ${import_picocolors6.default.cyan(value || "default")}`);
+    f2.success(`${settingKey} set to ${import_picocolors7.default.cyan(value || "default")}`);
   }
 }
 async function editTools(configPath) {
@@ -2921,9 +3628,9 @@ async function editTools(configPath) {
     "todoread"
   ];
   console.log();
-  console.log(import_picocolors6.default.bold("  Tool Status"));
+  console.log(import_picocolors7.default.bold("  Tool Status"));
   for (const tool of commonTools) {
-    const status = config.tools[tool] === false ? import_picocolors6.default.red("off") : import_picocolors6.default.green("on");
+    const status = config.tools[tool] === false ? import_picocolors7.default.red("off") : import_picocolors7.default.green("on");
     console.log(`    ${status} ${tool}`);
   }
   console.log();
@@ -2957,7 +3664,7 @@ async function editTools(configPath) {
     const wasEnabled = config.tools[toolName] !== false;
     config.tools[toolName] = !wasEnabled;
     saveConfig(configPath, config);
-    const status = config.tools[toolName] ? import_picocolors6.default.green("enabled") : import_picocolors6.default.red("disabled");
+    const status = config.tools[toolName] ? import_picocolors7.default.green("enabled") : import_picocolors7.default.red("disabled");
     f2.success(`${toolName}: ${status}`);
   } else {
     const toolName = await te({
@@ -2980,13 +3687,13 @@ async function editTools(configPath) {
     }
     config.tools[toolName] = enabled;
     saveConfig(configPath, config);
-    f2.success(`Added ${toolName}: ${enabled ? import_picocolors6.default.green("on") : import_picocolors6.default.red("off")}`);
+    f2.success(`Added ${toolName}: ${enabled ? import_picocolors7.default.green("on") : import_picocolors7.default.red("off")}`);
   }
 }
 async function editShare(configPath) {
   const config = loadConfig(configPath);
   const current = config.share || "manual";
-  f2.info(`Current share setting: ${import_picocolors6.default.cyan(current)}`);
+  f2.info(`Current share setting: ${import_picocolors7.default.cyan(current)}`);
   const selected = await ie({
     message: "Share setting",
     options: [
@@ -3009,13 +3716,13 @@ async function editShare(configPath) {
   const shareValue = selected;
   config.share = shareValue;
   saveConfig(configPath, config);
-  f2.success(`Share set to ${import_picocolors6.default.cyan(shareValue)}`);
+  f2.success(`Share set to ${import_picocolors7.default.cyan(shareValue)}`);
 }
 async function editAutoupdate(configPath) {
   const config = loadConfig(configPath);
   const current = config.autoupdate ?? true;
   const display = current === "notify" ? "notify" : current ? "enabled" : "disabled";
-  f2.info(`Current autoupdate: ${import_picocolors6.default.cyan(display)}`);
+  f2.info(`Current autoupdate: ${import_picocolors7.default.cyan(display)}`);
   const selected = await ie({
     message: "Autoupdate behavior",
     options: [
@@ -3046,21 +3753,21 @@ async function editAutoupdate(configPath) {
     config.autoupdate = selectedValue === "true";
   }
   saveConfig(configPath, config);
-  f2.success(`Autoupdate set to ${import_picocolors6.default.cyan(selectedValue)}`);
+  f2.success(`Autoupdate set to ${import_picocolors7.default.cyan(selectedValue)}`);
 }
 
 // src/commands/init.ts
 import { execSync } from "node:child_process";
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync3,
-  readdirSync as readdirSync2,
-  writeFileSync as writeFileSync3
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
+  writeFileSync as writeFileSync4
 } from "node:fs";
-import { basename, dirname, join as join3 } from "node:path";
+import { basename as basename2, dirname, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
-var import_picocolors7 = __toESM(require_picocolors(), 1);
+var import_picocolors8 = __toESM(require_picocolors(), 1);
 var EXCLUDED_DIRS = [
   "node_modules",
   ".git",
@@ -3077,12 +3784,12 @@ var EXCLUDED_FILES = [
   "pnpm-lock.yaml"
 ];
 function detectMode(targetDir) {
-  const opencodeDir = join3(targetDir, ".opencode");
-  if (existsSync3(opencodeDir)) {
+  const opencodeDir = join4(targetDir, ".opencode");
+  if (existsSync4(opencodeDir)) {
     return "already-initialized";
   }
-  if (existsSync3(targetDir)) {
-    const entries = readdirSync2(targetDir);
+  if (existsSync4(targetDir)) {
+    const entries = readdirSync3(targetDir);
     const hasCode = entries.some((e2) => !e2.startsWith(".") && !EXCLUDED_DIRS.includes(e2) && e2 !== "node_modules");
     if (hasCode) {
       return "add-config";
@@ -3094,12 +3801,12 @@ function getTemplateRoot() {
   const __filename2 = fileURLToPath(import.meta.url);
   const __dirname2 = dirname(__filename2);
   const possiblePaths = [
-    join3(__dirname2, "template"),
-    join3(__dirname2, "..", "..", ".opencode")
+    join4(__dirname2, "template"),
+    join4(__dirname2, "..", "..", ".opencode")
   ];
   for (const path of possiblePaths) {
-    const opencodeDir = join3(path, ".opencode");
-    if (existsSync3(opencodeDir)) {
+    const opencodeDir = join4(path, ".opencode");
+    if (existsSync4(opencodeDir)) {
       return path;
     }
   }
@@ -3113,20 +3820,20 @@ async function copyDir(src, dest) {
       continue;
     if (!entry.isDirectory() && EXCLUDED_FILES.includes(entry.name))
       continue;
-    const srcPath = join3(src, entry.name);
-    const destPath = join3(dest, entry.name);
+    const srcPath = join4(src, entry.name);
+    const destPath = join4(dest, entry.name);
     if (entry.isSymbolicLink()) {} else if (entry.isDirectory()) {
       await copyDir(srcPath, destPath);
     } else {
-      const content = readFileSync3(srcPath, "utf-8");
-      writeFileSync3(destPath, content);
+      const content = readFileSync4(srcPath, "utf-8");
+      writeFileSync4(destPath, content);
     }
   }
 }
 async function copyOpenCodeOnly(templateRoot, targetDir) {
-  const opencodeSrc = join3(templateRoot, ".opencode");
-  const opencodeDest = join3(targetDir, ".opencode");
-  if (!existsSync3(opencodeSrc)) {
+  const opencodeSrc = join4(templateRoot, ".opencode");
+  const opencodeDest = join4(targetDir, ".opencode");
+  if (!existsSync4(opencodeSrc)) {
     return false;
   }
   await copyDir(opencodeSrc, opencodeDest);
@@ -3137,20 +3844,20 @@ async function initCommand(options = {}) {
     return;
   const targetDir = process.cwd();
   const mode = detectMode(targetDir);
-  oe(import_picocolors7.default.bgCyan(import_picocolors7.default.black(" OpenCodeKit ")));
+  oe(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" OpenCodeKit ")));
   if (mode === "already-initialized" && !options.force) {
     f2.warn("Already initialized (.opencode/ exists)");
-    f2.info(`Use ${import_picocolors7.default.cyan("--force")} to reinitialize`);
+    f2.info(`Use ${import_picocolors8.default.cyan("--force")} to reinitialize`);
     $e("Nothing to do");
     return;
   }
   const templateRoot = getTemplateRoot();
   if (!templateRoot) {
     f2.error("Template not found. Please reinstall opencodekit.");
-    $e(import_picocolors7.default.red("Failed"));
+    $e(import_picocolors8.default.red("Failed"));
     process.exit(1);
   }
-  let projectName = basename(targetDir);
+  let projectName = basename2(targetDir);
   if (mode === "scaffold") {
     const name = await te({
       message: "Project name",
@@ -3166,7 +3873,7 @@ async function initCommand(options = {}) {
   const s = de();
   if (mode === "scaffold") {
     s.start("Scaffolding project");
-    mkdirSync2(targetDir, { recursive: true });
+    mkdirSync3(targetDir, { recursive: true });
   } else if (mode === "add-config") {
     s.start("Adding OpenCodeKit");
   } else {
@@ -3175,25 +3882,25 @@ async function initCommand(options = {}) {
   const success = await copyOpenCodeOnly(templateRoot, targetDir);
   if (!success) {
     s.stop("Failed");
-    $e(import_picocolors7.default.red("Template copy failed"));
+    $e(import_picocolors8.default.red("Template copy failed"));
     process.exit(1);
   }
   s.stop("Done");
   if (options.beads) {
-    const beadsDir = join3(targetDir, ".beads");
-    if (!existsSync3(beadsDir)) {
+    const beadsDir = join4(targetDir, ".beads");
+    if (!existsSync4(beadsDir)) {
       const bs = de();
       bs.start("Initializing .beads/");
       try {
         execSync("bd init", { cwd: targetDir, stdio: "ignore" });
         bs.stop("Beads initialized");
       } catch {
-        mkdirSync2(beadsDir, { recursive: true });
-        writeFileSync3(join3(beadsDir, "config.yaml"), `# Beads configuration
+        mkdirSync3(beadsDir, { recursive: true });
+        writeFileSync4(join4(beadsDir, "config.yaml"), `# Beads configuration
 version: 1
 `);
-        writeFileSync3(join3(beadsDir, "issues.jsonl"), "");
-        writeFileSync3(join3(beadsDir, "metadata.json"), JSON.stringify({ created: new Date().toISOString() }, null, 2));
+        writeFileSync4(join4(beadsDir, "issues.jsonl"), "");
+        writeFileSync4(join4(beadsDir, "metadata.json"), JSON.stringify({ created: new Date().toISOString() }, null, 2));
         bs.stop("Beads initialized (manual)");
       }
     } else {
@@ -3201,213 +3908,352 @@ version: 1
     }
   }
   le("cd .opencode && bun install", "Next steps");
-  $e(import_picocolors7.default.green("Ready to code!"));
+  $e(import_picocolors8.default.green("Ready to code!"));
 }
 
 // src/commands/menu.ts
-import { existsSync as existsSync6, lstatSync as lstatSync3, readdirSync as readdirSync5 } from "node:fs";
-import { basename as basename2, join as join6 } from "node:path";
-var import_picocolors10 = __toESM(require_picocolors(), 1);
+import { existsSync as existsSync7, lstatSync as lstatSync2, readFileSync as readFileSync7, readdirSync as readdirSync6 } from "node:fs";
+import { basename as basename4, join as join7 } from "node:path";
+var import_picocolors11 = __toESM(require_picocolors(), 1);
 
 // src/commands/skill.ts
-import { existsSync as existsSync4, lstatSync as lstatSync2, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "node:fs";
-import { join as join4 } from "node:path";
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync4,
+  rmSync,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+import { basename as basename3, join as join5 } from "node:path";
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 async function skillCommand(action) {
-  const opencodePath = join4(process.cwd(), ".opencode");
-  if (!existsSync4(opencodePath)) {
+  const opencodePath = join5(process.cwd(), ".opencode");
+  if (!existsSync5(opencodePath)) {
     notInitialized();
     return;
   }
+  const skillDir = join5(opencodePath, "skill");
   switch (action) {
     case "list":
-      await listSkills(opencodePath);
+      listSkills(skillDir);
+      break;
+    case "create":
+      await createSkill(skillDir);
       break;
     case "add":
-      await addSkill(opencodePath);
+      await createSkill(skillDir);
       break;
     case "view": {
       const skillName = process.argv[4];
-      await viewSkill(opencodePath, skillName);
+      await viewSkill(skillDir, skillName);
+      break;
+    }
+    case "remove": {
+      const skillName = process.argv[4];
+      await removeSkill(skillDir, skillName);
       break;
     }
     default:
-      unknownAction(action, ["list", "add", "view"]);
+      unknownAction(action, ["list", "create", "view", "remove"]);
   }
 }
-function collectSkills(basePath) {
-  const skills = [];
-  if (!existsSync4(basePath))
-    return skills;
-  const tiers = ["core", "stack", "specialized"];
-  let hasTiers = false;
-  for (const tier of tiers) {
-    const tierPath = join4(basePath, tier);
-    if (existsSync4(tierPath)) {
-      hasTiers = true;
-      const entries = readdirSync3(tierPath);
-      for (const entry of entries) {
-        const entryPath = join4(tierPath, entry);
-        if (lstatSync2(entryPath).isDirectory()) {
-          skills.push({ name: entry, path: entryPath, tier });
-        }
-      }
+function parseFrontmatter3(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match)
+    return {};
+  const frontmatter = {};
+  const lines = match[1].split(`
+`);
+  let currentKey = null;
+  let multilineValue = "";
+  for (const line of lines) {
+    if (currentKey && line.match(/^\s+\S/)) {
+      multilineValue += ` ${line.trim()}`;
+      continue;
     }
-  }
-  if (!hasTiers) {
-    const entries = readdirSync3(basePath);
-    for (const entry of entries) {
-      const entryPath = join4(basePath, entry);
-      if (lstatSync2(entryPath).isDirectory()) {
-        skills.push({ name: entry, path: entryPath });
+    if (currentKey && multilineValue) {
+      frontmatter[currentKey] = multilineValue.trim();
+      currentKey = null;
+      multilineValue = "";
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      if (value === ">" || value === "|") {
+        currentKey = key;
+        multilineValue = "";
+        continue;
+      }
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
       }
+      frontmatter[key] = value;
     }
   }
-  return skills;
+  if (currentKey && multilineValue) {
+    frontmatter[currentKey] = multilineValue.trim();
+  }
+  return frontmatter;
 }
-async function listSkills(opencodePath) {
-  const locations = [
-    { path: join4(opencodePath, "superpowers", "skills"), name: "Superpowers" },
-    { path: join4(opencodePath, "skills"), name: "Project" }
-  ];
-  let totalSkills = 0;
-  for (const loc of locations) {
-    const skills = collectSkills(loc.path);
-    if (skills.length > 0) {
-      f2.info(import_picocolors8.default.bold(loc.name));
-      for (const skill of skills) {
-        const label = skill.tier ? `${skill.tier}/${skill.name}` : skill.name;
-        console.log(`  ${import_picocolors8.default.cyan("•")} ${label}`);
-      }
-      totalSkills += skills.length;
+function collectSkills(skillDir) {
+  const skills = [];
+  if (!existsSync5(skillDir))
+    return skills;
+  const entries = readdirSync4(skillDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const skillPath = join5(skillDir, entry.name);
+    const skillMdPath = join5(skillPath, "SKILL.md");
+    if (existsSync5(skillMdPath)) {
+      const content = readFileSync5(skillMdPath, "utf-8");
+      const frontmatter = parseFrontmatter3(content);
+      skills.push({
+        name: frontmatter.name || entry.name,
+        path: skillPath,
+        frontmatter
+      });
     }
   }
-  if (totalSkills === 0) {
-    showEmpty("skills", "ock skill add");
+  return skills.sort((a3, b3) => a3.name.localeCompare(b3.name));
+}
+function validateSkillName(name) {
+  if (!name)
+    return "Name is required";
+  if (name.length < 1 || name.length > 64) {
+    return "Name must be 1-64 characters";
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    return "Name must be lowercase letters, numbers, and hyphens (start with letter)";
   }
+  return;
 }
-async function addSkill(opencodePath) {
-  oe(import_picocolors8.default.bgYellow(import_picocolors8.default.black(" Add Skill ")));
-  const superpowersPath = join4(opencodePath, "superpowers", "skills");
-  const skills = collectSkills(superpowersPath);
+function validateDescription(desc) {
+  if (!desc)
+    return "Description is required";
+  if (desc.length < 1 || desc.length > 1024) {
+    return "Description must be 1-1024 characters";
+  }
+  return;
+}
+function listSkills(skillDir) {
+  const skills = collectSkills(skillDir);
   if (skills.length === 0) {
-    showEmpty("skills available to install");
-    $e("Done");
+    showEmpty("skills", "ock skill create");
     return;
   }
-  const selected = await ie({
-    message: "Select skill to install",
-    options: skills.map((s) => ({
-      value: s.name,
-      label: s.tier ? `${s.name} (${s.tier})` : s.name
-    }))
+  f2.info(import_picocolors9.default.bold("Skills"));
+  for (const skill of skills) {
+    const desc = skill.frontmatter.description ? import_picocolors9.default.dim(` - ${skill.frontmatter.description.slice(0, 60)}${skill.frontmatter.description.length > 60 ? "..." : ""}`) : "";
+    const version = skill.frontmatter.version ? import_picocolors9.default.yellow(` v${skill.frontmatter.version}`) : "";
+    console.log(`  ${import_picocolors9.default.cyan(skill.name)}${version}${desc}`);
+  }
+  console.log();
+  f2.info(import_picocolors9.default.dim(`Found ${skills.length} skill${skills.length === 1 ? "" : "s"} in .opencode/skill/`));
+}
+async function createSkill(skillDir) {
+  oe(import_picocolors9.default.bgYellow(import_picocolors9.default.black(" Create Skill ")));
+  if (!existsSync5(skillDir)) {
+    mkdirSync4(skillDir, { recursive: true });
+  }
+  const name = await te({
+    message: "Skill name",
+    placeholder: "my-skill",
+    validate: (value) => {
+      const error = validateSkillName(value);
+      if (error)
+        return error;
+      if (existsSync5(join5(skillDir, value))) {
+        return "Skill already exists";
+      }
+      return;
+    }
   });
-  if (lD(selected)) {
+  if (lD(name)) {
     ue("Cancelled");
     return;
   }
-  const skill = skills.find((s) => s.name === selected);
-  if (!skill)
+  const description = await te({
+    message: "Description (when should this skill be used?)",
+    placeholder: "Use when implementing authentication flows...",
+    validate: validateDescription
+  });
+  if (lD(description)) {
+    ue("Cancelled");
     return;
-  const skillMdPath = join4(skill.path, "SKILL.md");
-  if (!existsSync4(skillMdPath)) {
-    notFound("SKILL.md in", skill.name);
-    $e(import_picocolors8.default.red("Failed"));
+  }
+  const version = await te({
+    message: "Version",
+    placeholder: "1.0.0",
+    initialValue: "1.0.0"
+  });
+  if (lD(version)) {
+    ue("Cancelled");
     return;
   }
-  const content = readFileSync4(skillMdPath, "utf-8");
-  const lines = content.split(`
-`).slice(0, 10);
-  console.log();
-  console.log(import_picocolors8.default.dim("─".repeat(40)));
-  console.log(lines.join(`
-`));
-  if (content.split(`
-`).length > 10) {
-    console.log(import_picocolors8.default.dim("..."));
+  const skillPath = join5(skillDir, String(name));
+  mkdirSync4(skillPath, { recursive: true });
+  const template = `---
+name: ${name}
+description: >
+  ${description}
+version: "${version}"
+license: MIT
+---
+
+# ${String(name).split("-").map((w3) => w3.charAt(0).toUpperCase() + w3.slice(1)).join(" ")}
+
+## Overview
+
+${description}
+
+## When to Use
+
+Use this skill when:
+- Condition 1
+- Condition 2
+
+## Instructions
+
+<!-- Add your skill instructions here -->
+
+1. Step one
+2. Step two
+3. Step three
+
+## Examples
+
+\`\`\`typescript
+// Example usage
+\`\`\`
+
+## Rules
+
+1. Rule one
+2. Rule two
+`;
+  writeFileSync5(join5(skillPath, "SKILL.md"), template);
+  $e(import_picocolors9.default.green(`Created ${name} at .opencode/skill/${name}/SKILL.md`));
+}
+async function viewSkill(skillDir, skillNameArg) {
+  const skills = collectSkills(skillDir);
+  if (skills.length === 0) {
+    showEmpty("skills", "ock skill create");
+    return;
+  }
+  let skillName = skillNameArg;
+  if (!skillName) {
+    const options = skills.map((s) => ({
+      value: s.name,
+      label: s.name,
+      hint: s.frontmatter.description?.slice(0, 50) || ""
+    }));
+    const selected = await ie({
+      message: "Select skill to view",
+      options
+    });
+    if (lD(selected)) {
+      return;
+    }
+    skillName = selected;
   }
-  console.log(import_picocolors8.default.dim("─".repeat(40)));
+  const skill = skills.find((s) => s.name === skillName || basename3(s.path) === skillName);
+  if (!skill) {
+    notFound("Skill", skillName);
+    return;
+  }
+  const skillMdPath = join5(skill.path, "SKILL.md");
+  const content = readFileSync5(skillMdPath, "utf-8");
   console.log();
-  f2.success(`Skill "${skill.name}" is available at:`);
-  f2.info(import_picocolors8.default.cyan(skill.path));
-  le(`Skills in superpowers/ are auto-loaded.
-Use ${import_picocolors8.default.cyan("find_skills")} + ${import_picocolors8.default.cyan("use_skill")} in opencode.`, "Usage");
-  $e(import_picocolors8.default.green("Done!"));
-}
-async function viewSkill(opencodePath, skillName) {
-  const superpowersPath = join4(opencodePath, "superpowers", "skills");
-  const skills = collectSkills(superpowersPath);
+  console.log(import_picocolors9.default.dim("─".repeat(60)));
+  console.log(content);
+  console.log(import_picocolors9.default.dim("─".repeat(60)));
+}
+async function removeSkill(skillDir, skillNameArg) {
+  const skills = collectSkills(skillDir);
   if (skills.length === 0) {
-    showEmpty("skills");
+    showEmpty("skills", "ock skill create");
     return;
   }
+  let skillName = skillNameArg;
   if (!skillName) {
+    const options = skills.map((s) => ({
+      value: basename3(s.path),
+      label: s.name,
+      hint: s.frontmatter.description?.slice(0, 50) || ""
+    }));
     const selected = await ie({
-      message: "Select skill to view",
-      options: skills.map((s) => ({ value: s.name, label: s.name }))
+      message: "Select skill to remove",
+      options
     });
     if (lD(selected)) {
       return;
     }
     skillName = selected;
   }
-  const skill = skills.find((s) => s.name === skillName);
+  const skill = skills.find((s) => s.name === skillName || basename3(s.path) === skillName);
   if (!skill) {
     notFound("Skill", skillName);
     return;
   }
-  const skillMdPath = join4(skill.path, "SKILL.md");
-  if (!existsSync4(skillMdPath)) {
-    notFound("SKILL.md");
+  const confirm = await se({
+    message: `Remove skill "${skill.name}"? This will delete the entire folder.`,
+    initialValue: false
+  });
+  if (lD(confirm) || !confirm) {
+    ue("Cancelled");
     return;
   }
-  const content = readFileSync4(skillMdPath, "utf-8");
-  console.log();
-  console.log(import_picocolors8.default.dim("─".repeat(40)));
-  console.log(content);
-  console.log(import_picocolors8.default.dim("─".repeat(40)));
+  rmSync(skill.path, { recursive: true, force: true });
+  f2.success(`Removed skill "${skill.name}"`);
 }
 
 // src/commands/upgrade.ts
 import {
   copyFileSync,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync5,
-  readdirSync as readdirSync4,
-  writeFileSync as writeFileSync4
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync5,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname2, join as join6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var import_picocolors9 = __toESM(require_picocolors(), 1);
+var import_picocolors10 = __toESM(require_picocolors(), 1);
 var PRESERVE_FILES = [
-  "opencode.json"
+  "opencode.json",
+  ".env"
 ];
 var PRESERVE_DIRS = [
   "agent",
   "command",
-  "memory"
+  "memory",
+  "skill",
+  "tool"
 ];
 var SKIP_DIRS = ["node_modules", ".git", "dist", "coverage"];
 function getTemplateRoot2() {
   const __filename2 = fileURLToPath2(import.meta.url);
   const __dirname2 = dirname2(__filename2);
   const possiblePaths = [
-    join5(__dirname2, "template"),
-    join5(__dirname2, "..", "..", ".opencode")
+    join6(__dirname2, "template"),
+    join6(__dirname2, "..", "..", ".opencode")
   ];
   for (const path of possiblePaths) {
-    const opencodeDir = join5(path, ".opencode");
-    if (existsSync5(opencodeDir)) {
+    const opencodeDir = join6(path, ".opencode");
+    if (existsSync6(opencodeDir)) {
       return path;
     }
   }
   return null;
 }
 function getCurrentVersion(opencodeDir) {
-  const versionFile = join5(opencodeDir, ".version");
-  if (existsSync5(versionFile)) {
-    return readFileSync5(versionFile, "utf-8").trim();
+  const versionFile = join6(opencodeDir, ".version");
+  if (existsSync6(versionFile)) {
+    return readFileSync6(versionFile, "utf-8").trim();
   }
   return null;
 }
@@ -3415,12 +4261,12 @@ function getPackageVersion() {
   const __filename2 = fileURLToPath2(import.meta.url);
   const __dirname2 = dirname2(__filename2);
   const pkgPaths = [
-    join5(__dirname2, "..", "..", "package.json"),
-    join5(__dirname2, "..", "package.json")
+    join6(__dirname2, "..", "..", "package.json"),
+    join6(__dirname2, "..", "package.json")
   ];
   for (const pkgPath of pkgPaths) {
-    if (existsSync5(pkgPath)) {
-      const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    if (existsSync6(pkgPath)) {
+      const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
       return pkg.version;
     }
   }
@@ -3438,19 +4284,19 @@ async function checkVersion(opencodeDir) {
 function copyDirWithPreserve(src, dest, preserveFiles, preserveDirs) {
   const updated = [];
   const preserved = [];
-  if (!existsSync5(dest)) {
-    mkdirSync3(dest, { recursive: true });
+  if (!existsSync6(dest)) {
+    mkdirSync5(dest, { recursive: true });
   }
-  const entries = readdirSync4(src, { withFileTypes: true });
+  const entries = readdirSync5(src, { withFileTypes: true });
   for (const entry of entries) {
     if (SKIP_DIRS.includes(entry.name))
       continue;
-    const srcPath = join5(src, entry.name);
-    const destPath = join5(dest, entry.name);
+    const srcPath = join6(src, entry.name);
+    const destPath = join6(dest, entry.name);
     if (entry.isDirectory()) {
       if (preserveDirs.includes(entry.name)) {
-        if (!existsSync5(destPath)) {
-          mkdirSync3(destPath, { recursive: true });
+        if (!existsSync6(destPath)) {
+          mkdirSync5(destPath, { recursive: true });
         }
         const subResult = copyDirPreserveExisting(srcPath, destPath);
         updated.push(...subResult.updated);
@@ -3460,7 +4306,7 @@ function copyDirWithPreserve(src, dest, preserveFiles, preserveDirs) {
         updated.push(...subResult.updated);
       }
     } else {
-      if (preserveFiles.includes(entry.name) && existsSync5(destPath)) {
+      if (preserveFiles.includes(entry.name) && existsSync6(destPath)) {
         preserved.push(entry.name);
       } else {
         copyFileSync(srcPath, destPath);
@@ -3473,20 +4319,20 @@ function copyDirWithPreserve(src, dest, preserveFiles, preserveDirs) {
 function copyDirPreserveExisting(src, dest) {
   const updated = [];
   const preserved = [];
-  const entries = readdirSync4(src, { withFileTypes: true });
+  const entries = readdirSync5(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join5(src, entry.name);
-    const destPath = join5(dest, entry.name);
+    const srcPath = join6(src, entry.name);
+    const destPath = join6(dest, entry.name);
     if (entry.isDirectory()) {
-      if (!existsSync5(destPath)) {
-        mkdirSync3(destPath, { recursive: true });
+      if (!existsSync6(destPath)) {
+        mkdirSync5(destPath, { recursive: true });
         const subResult = copyDirPreserveExisting(srcPath, destPath);
         updated.push(...subResult.updated);
       } else {
-        preserved.push(entry.name + "/");
+        preserved.push(`${entry.name}/`);
       }
     } else {
-      if (!existsSync5(destPath)) {
+      if (!existsSync6(destPath)) {
         copyFileSync(srcPath, destPath);
         updated.push(entry.name);
       } else {
@@ -3496,32 +4342,48 @@ function copyDirPreserveExisting(src, dest) {
   }
   return { updated, preserved };
 }
+function getAllFiles(dir, base = "") {
+  const files = [];
+  const entries = readdirSync5(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (SKIP_DIRS.includes(entry.name))
+      continue;
+    const relativePath = join6(base, entry.name);
+    const fullPath = join6(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...getAllFiles(fullPath, relativePath));
+    } else {
+      files.push(relativePath);
+    }
+  }
+  return files;
+}
 async function upgradeCommand(options = {}) {
   if (process.argv.includes("--quiet"))
     return;
   const cwd = process.cwd();
-  const opencodeDir = join5(cwd, ".opencode");
-  if (!existsSync5(opencodeDir)) {
+  const opencodeDir = join6(cwd, ".opencode");
+  if (!existsSync6(opencodeDir)) {
     notInitialized();
     return;
   }
-  oe(import_picocolors9.default.bgCyan(import_picocolors9.default.black(" Upgrade ")));
+  oe(import_picocolors10.default.bgCyan(import_picocolors10.default.black(" Upgrade ")));
   const versionInfo = await checkVersion(opencodeDir);
   console.log();
-  console.log(`  ${import_picocolors9.default.bold("Installed")}  ${import_picocolors9.default.cyan(versionInfo.current || "unknown")}`);
-  console.log(`  ${import_picocolors9.default.bold("Latest")}     ${import_picocolors9.default.cyan(versionInfo.latest || "unknown")}`);
+  console.log(`  ${import_picocolors10.default.bold("Installed")}  ${import_picocolors10.default.cyan(versionInfo.current || "unknown")}`);
+  console.log(`  ${import_picocolors10.default.bold("Latest")}     ${import_picocolors10.default.cyan(versionInfo.latest || "unknown")}`);
   console.log();
   if (options.check) {
     if (versionInfo.needsUpdate) {
-      f2.info(`Update available: ${import_picocolors9.default.cyan(versionInfo.latest)}`);
-      $e(`Run ${import_picocolors9.default.cyan("ock upgrade")} to update`);
+      f2.info(`Update available: ${import_picocolors10.default.cyan(versionInfo.latest)}`);
+      $e(`Run ${import_picocolors10.default.cyan("ock upgrade")} to update`);
     } else {
-      $e(import_picocolors9.default.green("Already up to date"));
+      $e(import_picocolors10.default.green("Already up to date"));
     }
     return;
   }
   if (!versionInfo.needsUpdate && !options.force) {
-    $e(import_picocolors9.default.green("Already up to date"));
+    $e(import_picocolors10.default.green("Already up to date"));
     return;
   }
   const templateRoot = getTemplateRoot2();
@@ -3529,8 +4391,8 @@ async function upgradeCommand(options = {}) {
     showError("Template not found", "Reinstall opencodekit");
     return;
   }
-  const templateOpencode = join5(templateRoot, ".opencode");
-  if (!existsSync5(templateOpencode)) {
+  const templateOpencode = join6(templateRoot, ".opencode");
+  if (!existsSync6(templateOpencode)) {
     showError("Template .opencode not found");
     return;
   }
@@ -3547,7 +4409,7 @@ async function upgradeCommand(options = {}) {
   s.start("Upgrading");
   const result = copyDirWithPreserve(templateOpencode, opencodeDir, PRESERVE_FILES, PRESERVE_DIRS);
   if (versionInfo.latest) {
-    writeFileSync4(join5(opencodeDir, ".version"), versionInfo.latest);
+    writeFileSync6(join6(opencodeDir, ".version"), versionInfo.latest);
   }
   s.stop("Done");
   if (result.updated.length > 0) {
@@ -3556,13 +4418,55 @@ async function upgradeCommand(options = {}) {
   if (result.preserved.length > 0) {
     f2.info(`Preserved ${result.preserved.length} user files`);
   }
+  const installedFiles = getAllFiles(opencodeDir);
+  const templateFiles = getAllFiles(templateOpencode);
+  const orphans = installedFiles.filter((file) => {
+    if (file === ".version")
+      return false;
+    if (PRESERVE_FILES.includes(file))
+      return false;
+    if (file === ".env" || file.endsWith(".env"))
+      return false;
+    return !templateFiles.includes(file);
+  });
+  if (orphans.length > 0) {
+    f2.info(`${import_picocolors10.default.yellow(orphans.length.toString())} files found that are not in the template (orphans).`);
+    if (options.prune) {
+      const s2 = de();
+      s2.start("Pruning orphans");
+      for (const orphan of orphans) {
+        rmSync2(join6(opencodeDir, orphan));
+      }
+      s2.stop(`Removed ${orphans.length} files`);
+    } else {
+      const shouldPrune = await se({
+        message: "Do you want to review and delete them?",
+        initialValue: false
+      });
+      if (!lD(shouldPrune) && shouldPrune) {
+        const selected = await ae({
+          message: "Select files to delete",
+          options: orphans.map((o2) => ({ value: o2, label: o2 })),
+          required: false
+        });
+        if (!lD(selected) && selected.length > 0) {
+          const s2 = de();
+          s2.start("Deleting files");
+          for (const file of selected) {
+            rmSync2(join6(opencodeDir, file));
+          }
+          s2.stop(`Deleted ${selected.length} files`);
+        }
+      }
+    }
+  }
   le("cd .opencode && bun install", "Run if dependencies changed");
-  $e(import_picocolors9.default.green(`Upgraded to ${versionInfo.latest}`));
+  $e(import_picocolors10.default.green(`Upgraded to ${versionInfo.latest}`));
 }
 
 // src/commands/menu.ts
 async function interactiveMenu(version) {
-  oe(import_picocolors10.default.bgCyan(import_picocolors10.default.black(` OpenCodeKit v${version} `)));
+  oe(import_picocolors11.default.bgCyan(import_picocolors11.default.black(` OpenCodeKit v${version} `)));
   const action = await ie({
     message: "What do you want to do?",
     options: [
@@ -3613,115 +4517,1437 @@ async function interactiveMenu(version) {
       break;
   }
 }
+var KNOWN_CONFIG_PROPERTIES = new Set([
+  "$schema",
+  "model",
+  "small_model",
+  "theme",
+  "share",
+  "autoupdate",
+  "mcp",
+  "permission",
+  "keybinds",
+  "provider",
+  "agent",
+  "formatter",
+  "plugin",
+  "tools",
+  "tui",
+  "command",
+  "watcher",
+  "snapshot",
+  "disabled_providers",
+  "enabled_providers",
+  "username",
+  "lsp",
+  "instructions",
+  "enterprise",
+  "experimental",
+  "compaction"
+]);
 async function doctorCommand() {
   if (process.argv.includes("--quiet"))
     return;
   const cwd = process.cwd();
-  const opencodeDir = join6(cwd, ".opencode");
+  const opencodeDir = join7(cwd, ".opencode");
+  oe(import_picocolors11.default.bgBlue(import_picocolors11.default.white(" Doctor - Health Check ")));
   const checks = [];
+  const warnings = [];
+  console.log();
+  console.log(import_picocolors11.default.bold("  Structure"));
   checks.push({
     name: ".opencode/ exists",
-    ok: existsSync6(opencodeDir),
+    ok: existsSync7(opencodeDir),
     fix: "ock init"
   });
+  const configPath = join7(opencodeDir, "opencode.json");
   checks.push({
     name: "opencode.json exists",
-    ok: existsSync6(join6(opencodeDir, "opencode.json")),
+    ok: existsSync7(configPath),
     fix: "ock init --force"
   });
   checks.push({
     name: "package.json exists",
-    ok: existsSync6(join6(opencodeDir, "package.json")),
+    ok: existsSync7(join7(opencodeDir, "package.json")),
     fix: "ock init --force"
   });
   checks.push({
     name: "Dependencies installed",
-    ok: existsSync6(join6(opencodeDir, "node_modules")),
+    ok: existsSync7(join7(opencodeDir, "node_modules")),
     fix: "cd .opencode && bun install"
   });
-  const agentDir = join6(opencodeDir, "agent");
-  const hasAgents = existsSync6(agentDir) && readdirSync5(agentDir).some((f3) => f3.endsWith(".md"));
-  checks.push({
-    name: "Agents configured",
-    ok: hasAgents,
-    fix: "ock agent add"
-  });
-  f2.info(import_picocolors10.default.bold("Health Check"));
+  displayChecks(checks.slice(-4));
+  if (existsSync7(configPath)) {
+    console.log();
+    console.log(import_picocolors11.default.bold("  Configuration"));
+    const configChecks = [];
+    try {
+      const configContent = readFileSync7(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      configChecks.push({
+        name: "$schema reference",
+        ok: !!config.$schema,
+        fix: 'Add "$schema": "https://opencode.ai/config.json"',
+        warn: true
+      });
+      const unknownProps = Object.keys(config).filter((k2) => !KNOWN_CONFIG_PROPERTIES.has(k2));
+      if (unknownProps.length > 0) {
+        warnings.push({
+          name: `Unknown config properties: ${unknownProps.join(", ")}`,
+          ok: false,
+          warn: true
+        });
+      }
+      configChecks.push({
+        name: "Model configured",
+        ok: !!config.model,
+        fix: "ock config model",
+        warn: true
+      });
+      if (config.mcp) {
+        const mcpServers = Object.keys(config.mcp);
+        const invalidMcp = mcpServers.filter((name) => {
+          const server = config.mcp[name];
+          return !server.command && !server.url;
+        });
+        configChecks.push({
+          name: `MCP servers (${mcpServers.length} configured)`,
+          ok: invalidMcp.length === 0,
+          fix: invalidMcp.length > 0 ? `Fix: ${invalidMcp.join(", ")} need command or url` : undefined
+        });
+      }
+      if (config.agent) {
+        const configuredAgents = Object.keys(config.agent);
+        const agentDir2 = join7(opencodeDir, "agent");
+        const missingFiles = configuredAgents.filter((name) => !existsSync7(join7(agentDir2, `${name}.md`)));
+        if (missingFiles.length > 0) {
+          warnings.push({
+            name: `Agent config without files: ${missingFiles.join(", ")}`,
+            ok: false,
+            warn: true
+          });
+        }
+      }
+      checks.push(...configChecks);
+      displayChecks(configChecks);
+    } catch (err) {
+      checks.push({
+        name: "Valid JSON syntax",
+        ok: false,
+        fix: "Fix JSON syntax errors in opencode.json"
+      });
+      displayChecks([checks[checks.length - 1]]);
+    }
+  }
   console.log();
-  let issues = 0;
+  console.log(import_picocolors11.default.bold("  Agents"));
+  const agentDir = join7(opencodeDir, "agent");
+  const agentChecks = [];
+  if (existsSync7(agentDir)) {
+    const agentFiles = readdirSync6(agentDir).filter((f3) => f3.endsWith(".md"));
+    agentChecks.push({
+      name: `Agent files (${agentFiles.length} found)`,
+      ok: agentFiles.length > 0,
+      fix: "ock agent create"
+    });
+    for (const file of agentFiles) {
+      const content = readFileSync7(join7(agentDir, file), "utf-8");
+      const hasFrontmatter = content.startsWith("---");
+      const hasMode = content.includes("mode:");
+      if (!hasFrontmatter) {
+        warnings.push({
+          name: `${file}: Missing frontmatter`,
+          ok: false,
+          warn: true
+        });
+      } else if (!hasMode) {
+        warnings.push({
+          name: `${file}: Missing mode in frontmatter`,
+          ok: false,
+          warn: true
+        });
+      }
+    }
+  } else {
+    agentChecks.push({
+      name: "agent/ directory",
+      ok: false,
+      fix: "ock agent create"
+    });
+  }
+  checks.push(...agentChecks);
+  displayChecks(agentChecks);
+  console.log();
+  console.log(import_picocolors11.default.bold("  Skills"));
+  const skillDir = join7(opencodeDir, "skill");
+  const skillChecks = [];
+  if (existsSync7(skillDir)) {
+    const skillFolders = readdirSync6(skillDir).filter((f3) => lstatSync2(join7(skillDir, f3)).isDirectory());
+    const validSkills = skillFolders.filter((folder) => existsSync7(join7(skillDir, folder, "SKILL.md")));
+    skillChecks.push({
+      name: `Skills (${validSkills.length} valid)`,
+      ok: validSkills.length > 0,
+      fix: "ock skill create"
+    });
+    const invalidFolders = skillFolders.filter((f3) => !existsSync7(join7(skillDir, f3, "SKILL.md")));
+    if (invalidFolders.length > 0) {
+      warnings.push({
+        name: `Skill folders missing SKILL.md: ${invalidFolders.slice(0, 3).join(", ")}${invalidFolders.length > 3 ? "..." : ""}`,
+        ok: false,
+        warn: true
+      });
+    }
+    for (const folder of validSkills.slice(0, 5)) {
+      const content = readFileSync7(join7(skillDir, folder, "SKILL.md"), "utf-8");
+      const hasFrontmatter = content.startsWith("---");
+      const hasName = content.includes("name:");
+      const hasDescription = content.includes("description:");
+      if (!hasFrontmatter || !hasName || !hasDescription) {
+        warnings.push({
+          name: `${folder}: Missing required frontmatter (name, description)`,
+          ok: false,
+          warn: true
+        });
+      }
+    }
+  } else {
+    skillChecks.push({
+      name: "skill/ directory",
+      ok: false,
+      fix: "ock skill create",
+      warn: true
+    });
+  }
+  checks.push(...skillChecks);
+  displayChecks(skillChecks);
+  console.log();
+  console.log(import_picocolors11.default.bold("  Tools"));
+  const toolDir = join7(opencodeDir, "tool");
+  const toolChecks = [];
+  if (existsSync7(toolDir)) {
+    const toolFiles = readdirSync6(toolDir).filter((f3) => f3.endsWith(".ts"));
+    toolChecks.push({
+      name: `Custom tools (${toolFiles.length} found)`,
+      ok: true
+    });
+    for (const file of toolFiles.slice(0, 5)) {
+      const content = readFileSync7(join7(toolDir, file), "utf-8");
+      const hasExport = content.includes("export default") || content.includes("export const");
+      const hasTool = content.includes("tool(");
+      if (!hasExport || !hasTool) {
+        warnings.push({
+          name: `${file}: Missing tool() export`,
+          ok: false,
+          warn: true
+        });
+      }
+    }
+  } else {
+    toolChecks.push({
+      name: "tool/ directory (optional)",
+      ok: true
+    });
+  }
+  checks.push(...toolChecks);
+  displayChecks(toolChecks);
+  const errors = checks.filter((c2) => !c2.ok && !c2.warn);
+  const warningCount = warnings.length + checks.filter((c2) => !c2.ok && c2.warn).length;
+  if (warnings.length > 0) {
+    console.log();
+    console.log(import_picocolors11.default.bold("  Warnings"));
+    for (const warn of warnings.slice(0, 5)) {
+      console.log(`  ${import_picocolors11.default.yellow("!")} ${warn.name}`);
+    }
+    if (warnings.length > 5) {
+      console.log(import_picocolors11.default.dim(`    ... and ${warnings.length - 5} more`));
+    }
+  }
+  console.log();
+  if (errors.length === 0 && warningCount === 0) {
+    $e(import_picocolors11.default.green("All checks passed!"));
+  } else if (errors.length === 0) {
+    $e(import_picocolors11.default.yellow(`Passed with ${warningCount} warning${warningCount > 1 ? "s" : ""}`));
+  } else {
+    $e(import_picocolors11.default.red(`${errors.length} error${errors.length > 1 ? "s" : ""}, ${warningCount} warning${warningCount > 1 ? "s" : ""}`));
+  }
+}
+function displayChecks(checks) {
   for (const check of checks) {
     if (check.ok) {
-      console.log(`  ${import_picocolors10.default.green("✓")} ${check.name}`);
+      console.log(`  ${import_picocolors11.default.green("✓")} ${check.name}`);
+    } else if (check.warn) {
+      console.log(`  ${import_picocolors11.default.yellow("!")} ${check.name}`);
+      if (check.fix) {
+        console.log(`    ${import_picocolors11.default.dim("→")} ${import_picocolors11.default.dim(check.fix)}`);
+      }
     } else {
-      console.log(`  ${import_picocolors10.default.red("✗")} ${check.name}`);
+      console.log(`  ${import_picocolors11.default.red("✗")} ${check.name}`);
       if (check.fix) {
-        console.log(`    ${import_picocolors10.default.dim("→ Run:")} ${import_picocolors10.default.cyan(check.fix)}`);
+        console.log(`    ${import_picocolors11.default.dim("→ Run:")} ${import_picocolors11.default.cyan(check.fix)}`);
       }
-      issues++;
     }
   }
-  console.log();
-  if (issues === 0) {
-    $e(import_picocolors10.default.green("All checks passed!"));
-  } else {
-    $e(import_picocolors10.default.yellow(`${issues} issue${issues > 1 ? "s" : ""} found`));
-  }
 }
 async function statusCommand() {
   if (process.argv.includes("--quiet"))
     return;
   const cwd = process.cwd();
-  const opencodeDir = join6(cwd, ".opencode");
-  if (!existsSync6(opencodeDir)) {
+  const opencodeDir = join7(cwd, ".opencode");
+  if (!existsSync7(opencodeDir)) {
     notInitialized();
     return;
   }
-  const projectName = basename2(cwd);
-  oe(import_picocolors10.default.bgCyan(import_picocolors10.default.black(` ${projectName} `)));
-  const agentDir = join6(opencodeDir, "agent");
+  const projectName = basename4(cwd);
+  oe(import_picocolors11.default.bgCyan(import_picocolors11.default.black(` ${projectName} `)));
+  const agentDir = join7(opencodeDir, "agent");
   let agentNames = [];
-  if (existsSync6(agentDir)) {
-    agentNames = readdirSync5(agentDir).filter((f3) => f3.endsWith(".md") && lstatSync3(join6(agentDir, f3)).isFile()).map((f3) => f3.replace(".md", ""));
+  if (existsSync7(agentDir)) {
+    agentNames = readdirSync6(agentDir).filter((f3) => f3.endsWith(".md") && lstatSync2(join7(agentDir, f3)).isFile()).map((f3) => f3.replace(".md", ""));
   }
-  const superpowersPath = join6(opencodeDir, "superpowers", "skills");
+  const skillDir = join7(opencodeDir, "skill");
   let skillCount = 0;
-  if (existsSync6(superpowersPath)) {
-    const tiers = ["core", "stack", "specialized"];
-    let hasTiers = false;
-    for (const tier of tiers) {
-      const tierPath = join6(superpowersPath, tier);
-      if (existsSync6(tierPath)) {
-        hasTiers = true;
-        skillCount += readdirSync5(tierPath).filter((e2) => lstatSync3(join6(tierPath, e2)).isDirectory()).length;
-      }
-    }
-    if (!hasTiers) {
-      skillCount = readdirSync5(superpowersPath).filter((e2) => lstatSync3(join6(superpowersPath, e2)).isDirectory()).length;
-    }
+  if (existsSync7(skillDir)) {
+    skillCount = readdirSync6(skillDir).filter((f3) => lstatSync2(join7(skillDir, f3)).isDirectory() && existsSync7(join7(skillDir, f3, "SKILL.md"))).length;
   }
-  const commandDir = join6(opencodeDir, "command");
+  const commandDir = join7(opencodeDir, "command");
   let commandCount = 0;
-  if (existsSync6(commandDir)) {
-    commandCount = readdirSync5(commandDir).filter((f3) => f3.endsWith(".md")).length;
+  if (existsSync7(commandDir)) {
+    commandCount = readdirSync6(commandDir).filter((f3) => f3.endsWith(".md")).length;
+  }
+  const toolDir = join7(opencodeDir, "tool");
+  let toolCount = 0;
+  if (existsSync7(toolDir)) {
+    toolCount = readdirSync6(toolDir).filter((f3) => f3.endsWith(".ts")).length;
+  }
+  const configPath = join7(opencodeDir, "opencode.json");
+  let mcpCount = 0;
+  if (existsSync7(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync7(configPath, "utf-8"));
+      mcpCount = Object.keys(config.mcp || {}).length;
+    } catch {}
   }
   console.log();
-  console.log(`  ${import_picocolors10.default.bold("Agents")}     ${import_picocolors10.default.cyan(String(agentNames.length))}`);
+  console.log(`  ${import_picocolors11.default.bold("Agents")}     ${import_picocolors11.default.cyan(String(agentNames.length))}`);
   if (agentNames.length > 0) {
-    console.log(`             ${import_picocolors10.default.dim(agentNames.join(", "))}`);
+    console.log(`             ${import_picocolors11.default.dim(agentNames.join(", "))}`);
   }
   console.log();
-  console.log(`  ${import_picocolors10.default.bold("Skills")}     ${import_picocolors10.default.cyan(String(skillCount))}`);
+  console.log(`  ${import_picocolors11.default.bold("Skills")}     ${import_picocolors11.default.cyan(String(skillCount))}`);
+  console.log();
+  console.log(`  ${import_picocolors11.default.bold("Commands")}   ${import_picocolors11.default.cyan(String(commandCount))}`);
   console.log();
-  console.log(`  ${import_picocolors10.default.bold("Commands")}   ${import_picocolors10.default.cyan(String(commandCount))}`);
+  console.log(`  ${import_picocolors11.default.bold("Tools")}      ${import_picocolors11.default.cyan(String(toolCount))}`);
   console.log();
-  if (!existsSync6(join6(opencodeDir, "node_modules"))) {
+  console.log(`  ${import_picocolors11.default.bold("MCP")}        ${import_picocolors11.default.cyan(String(mcpCount))}`);
+  console.log();
+  if (!existsSync7(join7(opencodeDir, "node_modules"))) {
     showWarning("Dependencies not installed", "cd .opencode && bun install");
   }
-  $e(import_picocolors10.default.dim(".opencode/"));
+  $e(import_picocolors11.default.dim(".opencode/"));
+}
+
+// src/tui/components/Browser.ts
+var import_picocolors12 = __toESM(require_picocolors(), 1);
+import { spawn } from "node:child_process";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
+import { join as join8 } from "node:path";
+
+// src/tui/utils/keyboard.ts
+import * as readline from "node:readline";
+function createKeyboardController() {
+  let rl = null;
+  let handler = null;
+  const keyListener = (_3, key) => {
+    if (!handler)
+      return;
+    const ctrl = key.ctrl ?? false;
+    if (key.name === "up")
+      handler("up", ctrl);
+    else if (key.name === "down")
+      handler("down", ctrl);
+    else if (key.name === "left")
+      handler("left", ctrl);
+    else if (key.name === "right")
+      handler("right", ctrl);
+    else if (key.name === "return")
+      handler("enter", ctrl);
+    else if (key.name === "escape")
+      handler("escape", ctrl);
+    else if (key.name === "backspace")
+      handler("backspace", ctrl);
+    else if (key.name === "tab")
+      handler("tab", ctrl);
+    else if (key.name === "c" && ctrl)
+      handler("quit", ctrl);
+    else if (key.sequence)
+      handler(key.sequence, ctrl);
+  };
+  return {
+    start(h2) {
+      handler = h2;
+      rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.on("keypress", keyListener);
+    },
+    stop() {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.removeListener("keypress", keyListener);
+      if (rl) {
+        rl.close();
+        rl = null;
+      }
+      handler = null;
+    }
+  };
+}
+
+// src/tui/components/Browser.ts
+async function runBrowser(options) {
+  const {
+    title,
+    items,
+    icon = "●",
+    color: itemColor = import_picocolors12.default.cyan,
+    onSelect,
+    onBack
+  } = options;
+  if (items.length === 0) {
+    console.clear();
+    console.log();
+    printEmptyBox(title);
+    console.log();
+    console.log(import_picocolors12.default.dim("  Press any key to go back..."));
+    return new Promise((resolve) => {
+      const kb = createKeyboardController();
+      kb.start(() => {
+        kb.stop();
+        resolve();
+      });
+    });
+  }
+  let selectedIndex = 0;
+  const pageSize = 14;
+  const render = () => {
+    console.clear();
+    const totalWidth = Math.min(process.stdout.columns || 80, 120) - 4;
+    const listWidth = Math.floor(totalWidth * 0.35);
+    const previewWidth = totalWidth - listWidth - 3;
+    console.log();
+    console.log(`  ${import_picocolors12.default.bgCyan(import_picocolors12.default.black(` ${title} Browser `))} ${import_picocolors12.default.dim(`${items.length} items`)}`);
+    console.log();
+    const startIdx = Math.max(0, Math.min(selectedIndex - Math.floor(pageSize / 2), items.length - pageSize));
+    const endIdx = Math.min(startIdx + pageSize, items.length);
+    const visibleItems = items.slice(startIdx, endIdx);
+    const selected = items[selectedIndex];
+    const previewLines = getPreviewLines(selected, previewWidth - 2);
+    const maxRows = Math.max(visibleItems.length, previewLines.length, pageSize);
+    const listTitle = ` ${items.length} items `;
+    const previewTitle = " Preview ";
+    console.log(import_picocolors12.default.dim(`  ┌${listTitle}${"─".repeat(listWidth - listTitle.length)}┬${previewTitle}${"─".repeat(previewWidth - previewTitle.length)}┐`));
+    for (let i = 0;i < maxRows; i++) {
+      let leftContent = "";
+      let rightContent = "";
+      if (i < visibleItems.length) {
+        const itemIdx = startIdx + i;
+        const item = visibleItems[i];
+        const isSelected = itemIdx === selectedIndex;
+        const pointer = isSelected ? import_picocolors12.default.cyan("▶") : " ";
+        const itemIcon = isSelected ? itemColor(icon) : import_picocolors12.default.dim(icon);
+        const name = isSelected ? import_picocolors12.default.bold(itemColor(truncate(item.name, listWidth - 6))) : truncate(item.name, listWidth - 6);
+        leftContent = `${pointer}${itemIcon} ${name}`;
+      }
+      if (i < previewLines.length) {
+        rightContent = previewLines[i];
+      }
+      const leftPadded = padRight2(leftContent, listWidth - 1);
+      const rightPadded = padRight2(rightContent, previewWidth - 1);
+      console.log(`  ${import_picocolors12.default.dim("│")} ${leftPadded}${import_picocolors12.default.dim("│")} ${rightPadded}${import_picocolors12.default.dim("│")}`);
+    }
+    console.log(import_picocolors12.default.dim(`  └${"─".repeat(listWidth)}┴${"─".repeat(previewWidth)}┘`));
+    if (items.length > pageSize) {
+      const scrollPos = Math.round(selectedIndex / (items.length - 1) * 100);
+      console.log(import_picocolors12.default.dim(`  ${selectedIndex + 1}/${items.length} (${scrollPos}%)`));
+    }
+    console.log();
+    console.log(`  ${import_picocolors12.default.dim("[")}${import_picocolors12.default.cyan("↑↓")}${import_picocolors12.default.dim("] Navigate")}  ` + `${import_picocolors12.default.dim("[")}${import_picocolors12.default.green("Enter")}${import_picocolors12.default.dim("] View")}  ` + `${import_picocolors12.default.dim("[")}${import_picocolors12.default.yellow("e")}${import_picocolors12.default.dim("] Edit")}  ` + `${import_picocolors12.default.dim("[")}${import_picocolors12.default.red("q")}${import_picocolors12.default.dim("] Back")}`);
+    console.log();
+  };
+  return new Promise((resolve) => {
+    const kb = createKeyboardController();
+    const handleKey = async (key) => {
+      switch (key) {
+        case "up":
+          selectedIndex = Math.max(0, selectedIndex - 1);
+          render();
+          break;
+        case "down":
+          selectedIndex = Math.min(items.length - 1, selectedIndex + 1);
+          render();
+          break;
+        case "enter":
+          kb.stop();
+          await showFileViewer(items[selectedIndex]);
+          render();
+          kb.start(handleKey);
+          break;
+        case "e":
+          kb.stop();
+          await openInEditor(items[selectedIndex]);
+          render();
+          kb.start(handleKey);
+          break;
+        case "escape":
+        case "q":
+          kb.stop();
+          if (onBack)
+            onBack();
+          resolve();
+          break;
+        case "quit":
+          kb.stop();
+          process.exit(0);
+      }
+    };
+    render();
+    kb.start(handleKey);
+  });
+}
+function printEmptyBox(title) {
+  const width = Math.min(process.stdout.columns || 80, 120) - 4;
+  console.log(import_picocolors12.default.dim(`  ┌${"─".repeat(width - 2)}┐`));
+  console.log(`  ${import_picocolors12.default.dim("│")} ${padRight2(import_picocolors12.default.yellow(`No ${title.toLowerCase()} found`), width - 4)}${import_picocolors12.default.dim("│")}`);
+  console.log(`  ${import_picocolors12.default.dim("│")} ${padRight2("", width - 4)}${import_picocolors12.default.dim("│")}`);
+  console.log(`  ${import_picocolors12.default.dim("│")} ${padRight2(import_picocolors12.default.dim("Check your .opencode/ directory"), width - 4)}${import_picocolors12.default.dim("│")}`);
+  console.log(import_picocolors12.default.dim(`  └${"─".repeat(width - 2)}┘`));
+}
+function getPreviewLines(item, maxWidth) {
+  const lines = [];
+  lines.push(import_picocolors12.default.bold(import_picocolors12.default.cyan(item.name)));
+  lines.push(import_picocolors12.default.dim("─".repeat(Math.min(maxWidth, 40))));
+  const shortPath = item.path.replace(process.cwd(), ".");
+  lines.push(import_picocolors12.default.dim(`Path: ${truncate(shortPath, maxWidth - 6)}`));
+  lines.push("");
+  if (!existsSync8(item.path)) {
+    lines.push(import_picocolors12.default.red("(file not found)"));
+    return lines;
+  }
+  try {
+    const content = readFileSync8(item.path, "utf-8");
+    const contentLines = content.split(`
+`);
+    let inFrontmatter = false;
+    let description = "";
+    let startLine = 0;
+    for (let i = 0;i < Math.min(contentLines.length, 20); i++) {
+      const line = contentLines[i].trim();
+      if (i === 0 && line === "---") {
+        inFrontmatter = true;
+        continue;
+      }
+      if (inFrontmatter && line === "---") {
+        inFrontmatter = false;
+        startLine = i + 1;
+        continue;
+      }
+      if (inFrontmatter && line.startsWith("description:")) {
+        description = line.replace("description:", "").trim();
+      }
+    }
+    if (description) {
+      lines.push(import_picocolors12.default.green("Description:"));
+      const descWords = description.split(" ");
+      let currentLine = "";
+      for (const word of descWords) {
+        if (`${currentLine} ${word}`.length > maxWidth - 2) {
+          lines.push(`  ${currentLine.trim()}`);
+          currentLine = word;
+        } else {
+          currentLine += ` ${word}`;
+        }
+      }
+      if (currentLine.trim()) {
+        lines.push(`  ${currentLine.trim()}`);
+      }
+      lines.push("");
+    }
+    lines.push(import_picocolors12.default.dim("Content:"));
+    const previewLines = contentLines.slice(startLine, startLine + 8);
+    for (const line of previewLines) {
+      if (line.length > maxWidth - 2) {
+        lines.push(import_picocolors12.default.dim(`  ${line.substring(0, maxWidth - 5)}...`));
+      } else {
+        lines.push(import_picocolors12.default.dim(`  ${line}`));
+      }
+    }
+    if (contentLines.length > startLine + 8) {
+      lines.push("");
+      lines.push(import_picocolors12.default.dim(`  ... ${contentLines.length - startLine - 8} more lines`));
+    }
+  } catch {
+    lines.push(import_picocolors12.default.red("(could not read file)"));
+  }
+  return lines;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen)
+    return str;
+  return `${str.substring(0, maxLen - 1)}…`;
+}
+function padRight2(str, len) {
+  const stripped = stripAnsi(str);
+  const pad = Math.max(0, len - stripped.length);
+  return str + " ".repeat(pad);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+async function showFileViewer(item) {
+  if (!existsSync8(item.path)) {
+    console.clear();
+    console.log();
+    console.log(import_picocolors12.default.red(`  File not found: ${item.path}`));
+    console.log(import_picocolors12.default.dim("  Press any key to go back..."));
+    await waitForKey();
+    return;
+  }
+  const content = readFileSync8(item.path, "utf-8");
+  const lines = content.split(`
+`);
+  let scrollOffset = 0;
+  const pageSize = (process.stdout.rows || 24) - 6;
+  const renderViewer = () => {
+    console.clear();
+    const width = Math.min(process.stdout.columns || 80, 120) - 4;
+    console.log();
+    console.log(`  ${import_picocolors12.default.bgGreen(import_picocolors12.default.black(" View "))} ${import_picocolors12.default.cyan(item.name)}`);
+    console.log(import_picocolors12.default.dim(`  ${item.path.replace(process.cwd(), ".")}`));
+    console.log();
+    console.log(import_picocolors12.default.dim(`  ┌${"─".repeat(width - 2)}┐`));
+    const visibleLines = lines.slice(scrollOffset, scrollOffset + pageSize);
+    for (let i = 0;i < pageSize; i++) {
+      const lineNum = scrollOffset + i + 1;
+      const lineContent = visibleLines[i] ?? "";
+      const numStr = import_picocolors12.default.dim(`${String(lineNum).padStart(4, " ")} │ `);
+      const truncated = lineContent.length > width - 10 ? `${lineContent.substring(0, width - 13)}...` : lineContent;
+      console.log(`  ${import_picocolors12.default.dim("│")}${numStr}${truncated.padEnd(width - 10)}${import_picocolors12.default.dim("│")}`);
+    }
+    console.log(import_picocolors12.default.dim(`  └${"─".repeat(width - 2)}┘`));
+    console.log();
+    console.log(`  ${import_picocolors12.default.dim("[")}${import_picocolors12.default.cyan("↑↓")}${import_picocolors12.default.dim("] Scroll")}  ` + `${import_picocolors12.default.dim("[")}${import_picocolors12.default.yellow("PgUp/PgDn")}${import_picocolors12.default.dim("] Page")}  ` + `${import_picocolors12.default.dim("Line")} ${scrollOffset + 1}-${Math.min(scrollOffset + pageSize, lines.length)}/${lines.length}  ` + `${import_picocolors12.default.dim("[")}${import_picocolors12.default.red("q")}${import_picocolors12.default.dim("] Back")}`);
+  };
+  return new Promise((resolve) => {
+    const kb = createKeyboardController();
+    const handleKey = (key) => {
+      switch (key) {
+        case "up":
+          scrollOffset = Math.max(0, scrollOffset - 1);
+          renderViewer();
+          break;
+        case "down":
+          scrollOffset = Math.min(lines.length - pageSize, scrollOffset + 1);
+          renderViewer();
+          break;
+        case "pageup":
+        case "left":
+          scrollOffset = Math.max(0, scrollOffset - pageSize);
+          renderViewer();
+          break;
+        case "pagedown":
+        case "right":
+          scrollOffset = Math.min(lines.length - pageSize, scrollOffset + pageSize);
+          renderViewer();
+          break;
+        case "escape":
+        case "q":
+          kb.stop();
+          resolve();
+          break;
+      }
+    };
+    renderViewer();
+    kb.start(handleKey);
+  });
+}
+async function openInEditor(item) {
+  const editor = process.env.EDITOR || process.env.VISUAL || "vim";
+  console.clear();
+  console.log();
+  console.log(import_picocolors12.default.cyan(`  Opening ${item.name} in ${editor}...`));
+  return new Promise((resolve) => {
+    const child = spawn(editor, [item.path], {
+      stdio: "inherit"
+    });
+    child.on("exit", () => {
+      resolve();
+    });
+    child.on("error", async () => {
+      console.log(import_picocolors12.default.red(`  Failed to open editor: ${editor}`));
+      console.log(import_picocolors12.default.dim("  Set $EDITOR environment variable"));
+      console.log(import_picocolors12.default.dim("  Press any key to continue..."));
+      await waitForKey();
+      resolve();
+    });
+  });
+}
+function waitForKey() {
+  return new Promise((resolve) => {
+    const kb = createKeyboardController();
+    kb.start(() => {
+      kb.stop();
+      resolve();
+    });
+  });
+}
+function loadAgentItems() {
+  const cwd = process.cwd();
+  const agentDir = join8(cwd, ".opencode", "agent");
+  if (!existsSync8(agentDir))
+    return [];
+  const { readdirSync: readdirSync7, lstatSync: lstatSync3 } = __require("node:fs");
+  return readdirSync7(agentDir).filter((f3) => f3.endsWith(".md") && lstatSync3(join8(agentDir, f3)).isFile()).map((f3) => ({
+    name: f3.replace(".md", ""),
+    path: join8(agentDir, f3)
+  }));
+}
+function loadSkillItems() {
+  const cwd = process.cwd();
+  const skillDir = join8(cwd, ".opencode", "skill");
+  if (!existsSync8(skillDir))
+    return [];
+  const { readdirSync: readdirSync7, lstatSync: lstatSync3 } = __require("node:fs");
+  return readdirSync7(skillDir).filter((f3) => lstatSync3(join8(skillDir, f3)).isDirectory() && existsSync8(join8(skillDir, f3, "SKILL.md"))).map((f3) => ({
+    name: f3,
+    path: join8(skillDir, f3, "SKILL.md")
+  }));
+}
+
+// src/tui/components/ConfigEditor.ts
+var import_picocolors13 = __toESM(require_picocolors(), 1);
+import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join9 } from "node:path";
+async function runConfigEditor() {
+  const configPath = join9(process.cwd(), ".opencode", "opencode.json");
+  if (!existsSync9(configPath)) {
+    console.clear();
+    console.log();
+    console.log(import_picocolors13.default.red("  Config file not found: .opencode/opencode.json"));
+    console.log(import_picocolors13.default.dim("  Press any key to go back..."));
+    return new Promise((resolve) => {
+      const kb = createKeyboardController();
+      kb.start(() => {
+        kb.stop();
+        resolve();
+      });
+    });
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync9(configPath, "utf-8"));
+  } catch {
+    console.clear();
+    console.log();
+    console.log(import_picocolors13.default.red("  Failed to parse config file"));
+    console.log(import_picocolors13.default.dim("  Press any key to go back..."));
+    return new Promise((resolve) => {
+      const kb = createKeyboardController();
+      kb.start(() => {
+        kb.stop();
+        resolve();
+      });
+    });
+  }
+  const state = {
+    path: [],
+    selectedIndex: 0,
+    editMode: false,
+    editBuffer: "",
+    message: "",
+    messageType: "info"
+  };
+  const getSections = () => {
+    let current = config;
+    for (const key of state.path) {
+      if (typeof current === "object" && current !== null) {
+        current = current[key];
+      }
+    }
+    if (typeof current !== "object" || current === null) {
+      return [];
+    }
+    return Object.entries(current).map(([key, value]) => ({
+      key,
+      value,
+      type: getType(value)
+    }));
+  };
+  const getType = (value) => {
+    if (value === null)
+      return "null";
+    if (Array.isArray(value))
+      return "array";
+    return typeof value;
+  };
+  const formatValue = (section) => {
+    if (section.type === "object") {
+      const keys = Object.keys(section.value);
+      return import_picocolors13.default.dim(`{${keys.length} keys}`);
+    }
+    if (section.type === "array") {
+      const arr = section.value;
+      return import_picocolors13.default.dim(`[${arr.length} items]`);
+    }
+    if (section.type === "string") {
+      const str = section.value;
+      if (str.length > 35) {
+        return import_picocolors13.default.green(`"${str.substring(0, 32)}..."`);
+      }
+      return import_picocolors13.default.green(`"${str}"`);
+    }
+    if (section.type === "number") {
+      return import_picocolors13.default.yellow(String(section.value));
+    }
+    if (section.type === "boolean") {
+      return section.value ? import_picocolors13.default.green("true") : import_picocolors13.default.red("false");
+    }
+    return import_picocolors13.default.dim("null");
+  };
+  const getTypeIcon = (section) => {
+    switch (section.type) {
+      case "object":
+        return import_picocolors13.default.cyan("{}");
+      case "array":
+        return import_picocolors13.default.cyan("[]");
+      case "string":
+        return import_picocolors13.default.green('""');
+      case "number":
+        return import_picocolors13.default.yellow("#");
+      case "boolean":
+        return import_picocolors13.default.magenta("◉");
+      default:
+        return import_picocolors13.default.dim("○");
+    }
+  };
+  const setValue = (newValue) => {
+    const sections = getSections();
+    const section = sections[state.selectedIndex];
+    if (!section)
+      return false;
+    let target = config;
+    for (const key of state.path) {
+      target = target[key];
+    }
+    target[section.key] = newValue;
+    return true;
+  };
+  const saveConfig2 = () => {
+    try {
+      writeFileSync7(configPath, JSON.stringify(config, null, 2));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const render = () => {
+    console.clear();
+    const width = Math.min(process.stdout.columns || 80, 120) - 4;
+    const pathStr = state.path.length > 0 ? state.path.join(" → ") : "root";
+    console.log();
+    console.log(`  ${import_picocolors13.default.bgCyan(import_picocolors13.default.black(" Config Editor "))} ${import_picocolors13.default.dim(pathStr)}`);
+    console.log();
+    const sections = getSections();
+    const pageSize = 15;
+    const startIdx = Math.max(0, Math.min(state.selectedIndex - Math.floor(pageSize / 2), sections.length - pageSize));
+    const endIdx = Math.min(startIdx + pageSize, sections.length);
+    const boxTitle = ` ${sections.length} items `;
+    console.log(import_picocolors13.default.dim(`  ┌${boxTitle}${"─".repeat(width - boxTitle.length - 3)}┐`));
+    if (sections.length === 0) {
+      console.log(`  ${import_picocolors13.default.dim("│")} ${padRight3(import_picocolors13.default.dim("(empty)"), width - 4)}${import_picocolors13.default.dim("│")}`);
+    } else {
+      for (let i = startIdx;i < endIdx; i++) {
+        const section = sections[i];
+        const isSelected = i === state.selectedIndex;
+        const prefix = isSelected ? import_picocolors13.default.cyan("▶") : " ";
+        const typeIcon = getTypeIcon(section);
+        const keyPart = isSelected ? import_picocolors13.default.bold(import_picocolors13.default.cyan(section.key)) : section.key;
+        let content;
+        if (state.editMode && isSelected) {
+          content = `${prefix} ${typeIcon} ${keyPart}: ${import_picocolors13.default.bgBlue(import_picocolors13.default.white(state.editBuffer))}█`;
+        } else {
+          const valuePart = formatValue(section);
+          content = `${prefix} ${typeIcon} ${keyPart}: ${valuePart}`;
+        }
+        console.log(`  ${import_picocolors13.default.dim("│")} ${padRight3(content, width - 4)}${import_picocolors13.default.dim("│")}`);
+      }
+    }
+    console.log(import_picocolors13.default.dim(`  └${"─".repeat(width - 2)}┘`));
+    if (state.message) {
+      console.log();
+      const msgColor = state.messageType === "error" ? import_picocolors13.default.red : state.messageType === "success" ? import_picocolors13.default.green : import_picocolors13.default.dim;
+      console.log(`  ${msgColor(state.message)}`);
+    }
+    console.log();
+    if (state.editMode) {
+      console.log(`  ${import_picocolors13.default.dim("Type value,")} ${import_picocolors13.default.green("Enter")} ${import_picocolors13.default.dim("to save,")} ${import_picocolors13.default.red("Esc")} ${import_picocolors13.default.dim("to cancel")}`);
+    } else {
+      console.log(`  ${import_picocolors13.default.dim("[")}${import_picocolors13.default.cyan("↑↓")}${import_picocolors13.default.dim("] Nav")}  ` + `${import_picocolors13.default.dim("[")}${import_picocolors13.default.green("Enter")}${import_picocolors13.default.dim("] Edit/Drill")}  ` + `${import_picocolors13.default.dim("[")}${import_picocolors13.default.yellow("←")}${import_picocolors13.default.dim("] Back")}  ` + `${import_picocolors13.default.dim("[")}${import_picocolors13.default.magenta("s")}${import_picocolors13.default.dim("] Save")}  ` + `${import_picocolors13.default.dim("[")}${import_picocolors13.default.red("q")}${import_picocolors13.default.dim("] Quit")}`);
+    }
+    console.log();
+  };
+  return new Promise((resolve) => {
+    const kb = createKeyboardController();
+    const handleKey = (key) => {
+      const sections = getSections();
+      if (state.editMode) {
+        if (key === "escape") {
+          state.editMode = false;
+          state.editBuffer = "";
+          state.message = "";
+          render();
+        } else if (key === "enter") {
+          const section = sections[state.selectedIndex];
+          if (section) {
+            let newValue;
+            const buf = state.editBuffer.trim();
+            if (section.type === "boolean") {
+              newValue = buf === "true";
+            } else if (section.type === "number") {
+              newValue = Number(buf);
+              if (Number.isNaN(newValue)) {
+                state.message = "Invalid number";
+                state.messageType = "error";
+                render();
+                return;
+              }
+            } else if (section.type === "string") {
+              newValue = buf;
+            } else {
+              state.message = "Cannot edit complex types inline";
+              state.messageType = "error";
+              state.editMode = false;
+              render();
+              return;
+            }
+            if (setValue(newValue)) {
+              state.message = "Updated (press 's' to save)";
+              state.messageType = "success";
+            } else {
+              state.message = "Failed to update";
+              state.messageType = "error";
+            }
+          }
+          state.editMode = false;
+          state.editBuffer = "";
+          render();
+        } else if (key === "backspace") {
+          state.editBuffer = state.editBuffer.slice(0, -1);
+          render();
+        } else if (key.length === 1 && key.charCodeAt(0) >= 32) {
+          state.editBuffer += key;
+          render();
+        }
+        return;
+      }
+      switch (key) {
+        case "up":
+          state.selectedIndex = Math.max(0, state.selectedIndex - 1);
+          state.message = "";
+          render();
+          break;
+        case "down":
+          state.selectedIndex = Math.min(sections.length - 1, state.selectedIndex + 1);
+          state.message = "";
+          render();
+          break;
+        case "enter":
+        case "right": {
+          const section = sections[state.selectedIndex];
+          if (section) {
+            if (section.type === "object" || section.type === "array") {
+              state.path.push(section.key);
+              state.selectedIndex = 0;
+              state.message = "";
+            } else {
+              state.editMode = true;
+              state.editBuffer = String(section.value);
+              state.message = "";
+            }
+          }
+          render();
+          break;
+        }
+        case "left":
+        case "backspace":
+          if (state.path.length > 0) {
+            state.path.pop();
+            state.selectedIndex = 0;
+            state.message = "";
+            render();
+          }
+          break;
+        case "s":
+          if (saveConfig2()) {
+            state.message = "Config saved!";
+            state.messageType = "success";
+          } else {
+            state.message = "Failed to save";
+            state.messageType = "error";
+          }
+          render();
+          break;
+        case "escape":
+        case "q":
+          kb.stop();
+          resolve();
+          break;
+        case "quit":
+          kb.stop();
+          process.exit(0);
+      }
+    };
+    render();
+    kb.start(handleKey);
+  });
+}
+function padRight3(str, len) {
+  const stripped = stripAnsi2(str);
+  const pad = Math.max(0, len - stripped.length);
+  return str + " ".repeat(pad);
+}
+function stripAnsi2(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/tui/components/Dashboard.tsx
+var import_picocolors14 = __toESM(require_picocolors(), 1);
+function renderDashboard(data) {
+  const width = Math.min(process.stdout.columns || 80, 120) - 4;
+  console.clear();
+  console.log();
+  console.log(`  ${import_picocolors14.default.bgCyan(import_picocolors14.default.black(" OpenCodeKit Dashboard "))} ${import_picocolors14.default.dim(data.projectName)}`);
+  console.log();
+  printBox("Overview", width, () => {
+    const stats = [{
+      label: "Agents",
+      value: data.agents.length,
+      col: import_picocolors14.default.cyan
+    }, {
+      label: "Skills",
+      value: data.skills.length,
+      col: import_picocolors14.default.cyan
+    }, {
+      label: "Commands",
+      value: data.commands.length,
+      col: import_picocolors14.default.yellow
+    }, {
+      label: "Tools",
+      value: data.tools.length,
+      col: import_picocolors14.default.yellow
+    }, {
+      label: "MCP",
+      value: data.mcpServers.length,
+      col: import_picocolors14.default.magenta
+    }];
+    const statLine = stats.map((s) => `${import_picocolors14.default.dim(s.label)} ${s.col(import_picocolors14.default.bold(String(s.value)))}`).join("   ");
+    console.log(`  ${statLine}`);
+  });
+  console.log();
+  printTwoColumnBox({
+    title: "Agents",
+    items: data.agents,
+    icon: "●",
+    col: import_picocolors14.default.cyan
+  }, {
+    title: "Skills",
+    items: data.skills,
+    icon: "◆",
+    col: import_picocolors14.default.cyan
+  }, width, 8);
+  console.log();
+  printTwoColumnBox({
+    title: "Commands",
+    items: data.commands.map((c2) => `/${c2}`),
+    icon: "›",
+    col: import_picocolors14.default.yellow
+  }, {
+    title: "MCP Servers",
+    items: data.mcpServers,
+    icon: "◈",
+    col: import_picocolors14.default.magenta
+  }, width, 5);
+  console.log();
+  console.log(import_picocolors14.default.dim(`  ${"─".repeat(width - 4)}`));
+  console.log();
+  console.log(`  ${import_picocolors14.default.dim("[")}${import_picocolors14.default.cyan("a")}${import_picocolors14.default.dim("] Agents")}  ` + `${import_picocolors14.default.dim("[")}${import_picocolors14.default.cyan("s")}${import_picocolors14.default.dim("] Skills")}  ` + `${import_picocolors14.default.dim("[")}${import_picocolors14.default.yellow("c")}${import_picocolors14.default.dim("] Config")}  ` + `${import_picocolors14.default.dim("[")}${import_picocolors14.default.magenta("m")}${import_picocolors14.default.dim("] MCP")}  ` + `${import_picocolors14.default.dim("[")}${import_picocolors14.default.red("q")}${import_picocolors14.default.dim("] Quit")}`);
+  console.log();
+}
+function printBox(title, width, content) {
+  const innerWidth = width - 4;
+  const titlePadded = ` ${title} `;
+  const topLine = `┌${titlePadded}${"─".repeat(innerWidth - titlePadded.length)}┐`;
+  const bottomLine = `└${"─".repeat(innerWidth)}┘`;
+  console.log(import_picocolors14.default.dim(`  ${topLine}`));
+  content();
+  console.log(import_picocolors14.default.dim(`  ${bottomLine}`));
+}
+function printTwoColumnBox(left, right, totalWidth, maxItems) {
+  const colWidth = Math.floor((totalWidth - 7) / 2);
+  const leftTitle = ` ${left.title} `;
+  const rightTitle = ` ${right.title} `;
+  const leftBorder = `┌${leftTitle}${"─".repeat(colWidth - leftTitle.length)}`;
+  const rightBorder = `┬${rightTitle}${"─".repeat(colWidth - rightTitle.length)}┐`;
+  console.log(import_picocolors14.default.dim(`  ${leftBorder}${rightBorder}`));
+  const leftItems = formatItems(left.items, left.icon, left.col, maxItems);
+  const rightItems = formatItems(right.items, right.icon, right.col, maxItems);
+  const maxRows = Math.max(leftItems.length, rightItems.length);
+  for (let i = 0;i < maxRows; i++) {
+    const leftContent = leftItems[i] || "";
+    const rightContent = rightItems[i] || "";
+    const leftPadded = padRight4(leftContent, colWidth - 1);
+    const rightPadded = padRight4(rightContent, colWidth - 1);
+    console.log(`  ${import_picocolors14.default.dim("│")} ${leftPadded}${import_picocolors14.default.dim("│")} ${rightPadded}${import_picocolors14.default.dim("│")}`);
+  }
+  const bottomLine = `└${"─".repeat(colWidth)}┴${"─".repeat(colWidth)}┘`;
+  console.log(import_picocolors14.default.dim(`  ${bottomLine}`));
+}
+function formatItems(items, icon, col, maxItems) {
+  const result = [];
+  if (items.length === 0) {
+    result.push(import_picocolors14.default.dim("(none)"));
+    return result;
+  }
+  for (const item of items.slice(0, maxItems)) {
+    result.push(`${col(icon)} ${item}`);
+  }
+  if (items.length > maxItems) {
+    result.push(import_picocolors14.default.dim(`  +${items.length - maxItems} more`));
+  }
+  return result;
+}
+function padRight4(str, len) {
+  const stripped = stripAnsi3(str);
+  const pad = Math.max(0, len - stripped.length);
+  return str + " ".repeat(pad);
+}
+function stripAnsi3(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/tui/components/MCPMonitor.ts
+var import_picocolors15 = __toESM(require_picocolors(), 1);
+import { existsSync as existsSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+async function runMCPMonitor() {
+  const configPath = join10(process.cwd(), ".opencode", "opencode.json");
+  if (!existsSync10(configPath)) {
+    console.clear();
+    console.log();
+    console.log(import_picocolors15.default.red("  Config file not found: .opencode/opencode.json"));
+    console.log(import_picocolors15.default.dim("  Press any key to go back..."));
+    return new Promise((resolve) => {
+      const kb = createKeyboardController();
+      kb.start(() => {
+        kb.stop();
+        resolve();
+      });
+    });
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync10(configPath, "utf-8"));
+  } catch {
+    console.clear();
+    console.log();
+    console.log(import_picocolors15.default.red("  Failed to parse config file"));
+    console.log(import_picocolors15.default.dim("  Press any key to go back..."));
+    return new Promise((resolve) => {
+      const kb = createKeyboardController();
+      kb.start(() => {
+        kb.stop();
+        resolve();
+      });
+    });
+  }
+  const state = {
+    selectedIndex: 0,
+    message: "",
+    messageType: "info"
+  };
+  const getMCPServers = () => {
+    const mcp = config.mcp;
+    if (!mcp || typeof mcp !== "object")
+      return [];
+    return Object.entries(mcp).map(([name, value]) => {
+      const server = value;
+      return {
+        name,
+        type: server.type || "local",
+        enabled: server.enabled !== false,
+        command: server.command,
+        url: server.url
+      };
+    });
+  };
+  const toggleServer = (index) => {
+    const servers = getMCPServers();
+    const server = servers[index];
+    if (!server)
+      return false;
+    const mcp = config.mcp;
+    mcp[server.name].enabled = !server.enabled;
+    return true;
+  };
+  const saveConfig2 = () => {
+    try {
+      writeFileSync8(configPath, JSON.stringify(config, null, 2));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const render = () => {
+    console.clear();
+    const width = Math.min(process.stdout.columns || 80, 120) - 4;
+    console.log();
+    console.log(`  ${import_picocolors15.default.bgMagenta(import_picocolors15.default.white(" MCP Monitor "))} ${import_picocolors15.default.dim("Model Context Protocol")}`);
+    console.log();
+    const servers = getMCPServers();
+    const boxTitle = ` ${servers.length} servers `;
+    console.log(import_picocolors15.default.dim(`  ┌${boxTitle}${"─".repeat(width - boxTitle.length - 3)}┐`));
+    if (servers.length === 0) {
+      console.log(`  ${import_picocolors15.default.dim("│")} ${padRight5(import_picocolors15.default.dim("No MCP servers configured"), width - 4)}${import_picocolors15.default.dim("│")}`);
+      console.log(`  ${import_picocolors15.default.dim("│")} ${padRight5("", width - 4)}${import_picocolors15.default.dim("│")}`);
+      console.log(`  ${import_picocolors15.default.dim("│")} ${padRight5(import_picocolors15.default.dim("Add servers to .opencode/opencode.json:"), width - 4)}${import_picocolors15.default.dim("│")}`);
+      console.log(`  ${import_picocolors15.default.dim("│")} ${padRight5(import_picocolors15.default.dim('  "mcp": { "name": { "command": [...] } }'), width - 4)}${import_picocolors15.default.dim("│")}`);
+    } else {
+      const headerContent = `  ${import_picocolors15.default.bold("Status")}  ${import_picocolors15.default.bold("Type")}  ${import_picocolors15.default.bold("Name")}                ${import_picocolors15.default.bold("Details")}`;
+      console.log(`  ${import_picocolors15.default.dim("│")} ${padRight5(headerContent, width - 4)}${import_picocolors15.default.dim("│")}`);
+      console.log(`  ${import_picocolors15.default.dim("│")} ${padRight5(import_picocolors15.default.dim("─".repeat(width - 6)), width - 4)}${import_picocolors15.default.dim("│")}`);
+      for (let i = 0;i < servers.length; i++) {
+        const server = servers[i];
+        const isSelected = i === state.selectedIndex;
+        const prefix = isSelected ? import_picocolors15.default.cyan("▶") : " ";
+        const status = server.enabled ? import_picocolors15.default.green("●") : import_picocolors15.default.dim("○");
+        const typeIcon = server.type === "remote" ? import_picocolors15.default.blue("☁") : import_picocolors15.default.yellow("⚡");
+        const name = isSelected ? import_picocolors15.default.bold(import_picocolors15.default.cyan(server.name.padEnd(18))) : server.name.padEnd(18);
+        let details = "";
+        if (server.type === "remote" && server.url) {
+          details = import_picocolors15.default.dim(truncate2(server.url, 25));
+        } else if (server.command) {
+          details = import_picocolors15.default.dim(truncate2(server.command.join(" "), 25));
+        }
+        const rowContent = `${prefix} ${status}       ${typeIcon}     ${name}  ${details}`;
+        console.log(`  ${import_picocolors15.default.dim("│")} ${padRight5(rowContent, width - 4)}${import_picocolors15.default.dim("│")}`);
+      }
+    }
+    console.log(import_picocolors15.default.dim(`  └${"─".repeat(width - 2)}┘`));
+    console.log();
+    console.log(`  ${import_picocolors15.default.green("●")} ${import_picocolors15.default.dim("Enabled")}  ${import_picocolors15.default.dim("○")} ${import_picocolors15.default.dim("Disabled")}  ${import_picocolors15.default.yellow("⚡")} ${import_picocolors15.default.dim("Local")}  ${import_picocolors15.default.blue("☁")} ${import_picocolors15.default.dim("Remote")}`);
+    if (state.message) {
+      console.log();
+      const msgColor = state.messageType === "error" ? import_picocolors15.default.red : state.messageType === "success" ? import_picocolors15.default.green : import_picocolors15.default.dim;
+      console.log(`  ${msgColor(state.message)}`);
+    }
+    console.log();
+    console.log(`  ${import_picocolors15.default.dim("[")}${import_picocolors15.default.cyan("↑↓")}${import_picocolors15.default.dim("] Nav")}  ` + `${import_picocolors15.default.dim("[")}${import_picocolors15.default.green("Space")}${import_picocolors15.default.dim("] Toggle")}  ` + `${import_picocolors15.default.dim("[")}${import_picocolors15.default.magenta("s")}${import_picocolors15.default.dim("] Save")}  ` + `${import_picocolors15.default.dim("[")}${import_picocolors15.default.red("q")}${import_picocolors15.default.dim("] Back")}`);
+    console.log();
+  };
+  return new Promise((resolve) => {
+    const kb = createKeyboardController();
+    const handleKey = (key) => {
+      const currentServers = getMCPServers();
+      switch (key) {
+        case "up":
+          state.selectedIndex = Math.max(0, state.selectedIndex - 1);
+          state.message = "";
+          render();
+          break;
+        case "down":
+          state.selectedIndex = Math.min(currentServers.length - 1, state.selectedIndex + 1);
+          state.message = "";
+          render();
+          break;
+        case " ":
+        case "enter":
+          if (currentServers.length > 0) {
+            if (toggleServer(state.selectedIndex)) {
+              const server = currentServers[state.selectedIndex];
+              const newState = !server.enabled;
+              state.message = `${server.name}: ${newState ? "enabled" : "disabled"} (press 's' to save)`;
+              state.messageType = "success";
+            }
+          }
+          render();
+          break;
+        case "s":
+          if (saveConfig2()) {
+            state.message = "Config saved!";
+            state.messageType = "success";
+          } else {
+            state.message = "Failed to save";
+            state.messageType = "error";
+          }
+          render();
+          break;
+        case "escape":
+        case "q":
+          kb.stop();
+          resolve();
+          break;
+        case "quit":
+          kb.stop();
+          process.exit(0);
+      }
+    };
+    render();
+    kb.start(handleKey);
+  });
+}
+function truncate2(str, maxLen) {
+  if (str.length <= maxLen)
+    return str;
+  return `${str.substring(0, maxLen - 3)}...`;
+}
+function padRight5(str, len) {
+  const stripped = stripAnsi4(str);
+  const pad = Math.max(0, len - stripped.length);
+  return str + " ".repeat(pad);
+}
+function stripAnsi4(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/tui/hooks/useData.ts
+import { existsSync as existsSync11, lstatSync as lstatSync3, readFileSync as readFileSync11, readdirSync as readdirSync7 } from "node:fs";
+import { basename as basename5, join as join11 } from "node:path";
+function loadProjectData() {
+  const cwd = process.cwd();
+  const opencodeDir = join11(cwd, ".opencode");
+  const projectName = basename5(cwd);
+  const agentDir = join11(opencodeDir, "agent");
+  let agents = [];
+  if (existsSync11(agentDir)) {
+    agents = readdirSync7(agentDir).filter((f3) => f3.endsWith(".md") && lstatSync3(join11(agentDir, f3)).isFile()).map((f3) => f3.replace(".md", ""));
+  }
+  const skillDir = join11(opencodeDir, "skill");
+  let skills = [];
+  if (existsSync11(skillDir)) {
+    skills = readdirSync7(skillDir).filter((f3) => lstatSync3(join11(skillDir, f3)).isDirectory() && existsSync11(join11(skillDir, f3, "SKILL.md")));
+  }
+  const commandDir = join11(opencodeDir, "command");
+  let commands = [];
+  if (existsSync11(commandDir)) {
+    commands = readdirSync7(commandDir).filter((f3) => f3.endsWith(".md")).map((f3) => f3.replace(".md", ""));
+  }
+  const toolDir = join11(opencodeDir, "tool");
+  let tools = [];
+  if (existsSync11(toolDir)) {
+    tools = readdirSync7(toolDir).filter((f3) => f3.endsWith(".ts")).map((f3) => f3.replace(".ts", ""));
+  }
+  const configPath = join11(opencodeDir, "opencode.json");
+  let mcpServers = [];
+  if (existsSync11(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync11(configPath, "utf-8"));
+      mcpServers = Object.keys(config.mcp || {});
+    } catch {}
+  }
+  return {
+    projectName,
+    agents,
+    skills,
+    commands,
+    tools,
+    mcpServers
+  };
+}
+function isInitialized() {
+  const cwd = process.cwd();
+  return existsSync11(join11(cwd, ".opencode"));
+}
+
+// src/tui/index.ts
+async function launchTUI() {
+  if (!isInitialized()) {
+    notInitialized();
+    return;
+  }
+  await mainMenu();
+}
+async function mainMenu() {
+  const data = loadProjectData();
+  renderDashboard(data);
+  return new Promise((resolve) => {
+    const kb = createKeyboardController();
+    const handleKey = async (key) => {
+      switch (key) {
+        case "a":
+          kb.stop();
+          await browseAgents();
+          await mainMenu();
+          resolve();
+          break;
+        case "s":
+          kb.stop();
+          await browseSkills();
+          await mainMenu();
+          resolve();
+          break;
+        case "c":
+          kb.stop();
+          await runConfigEditor();
+          await mainMenu();
+          resolve();
+          break;
+        case "m":
+          kb.stop();
+          await runMCPMonitor();
+          await mainMenu();
+          resolve();
+          break;
+        case "q":
+        case "escape":
+        case "quit":
+          kb.stop();
+          console.clear();
+          resolve();
+          break;
+      }
+    };
+    kb.start(handleKey);
+  });
+}
+async function browseAgents() {
+  const items = loadAgentItems();
+  await runBrowser({
+    title: "Agents",
+    items,
+    onSelect: (item) => {
+      console.log(`Selected: ${item.name}`);
+    }
+  });
+}
+async function browseSkills() {
+  const items = loadSkillItems();
+  await runBrowser({
+    title: "Skills",
+    items,
+    onSelect: (item) => {
+      console.log(`Selected: ${item.name}`);
+    }
+  });
 }
 
 // src/utils/logger.ts
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_picocolors16 = __toESM(require_picocolors(), 1);
 var logger = {
   log: (message) => {
     if (!process.argv.includes("--quiet")) {
@@ -3730,32 +5956,32 @@ var logger = {
   },
   info: (message) => {
     if (!process.argv.includes("--quiet")) {
-      console.log(import_picocolors11.default.blue(`[i] ${message}`));
+      console.log(import_picocolors16.default.blue(`[i] ${message}`));
     }
   },
   success: (message) => {
     if (!process.argv.includes("--quiet")) {
-      console.log(import_picocolors11.default.green(`[+] ${message}`));
+      console.log(import_picocolors16.default.green(`[+] ${message}`));
     }
   },
   warn: (message) => {
     if (!process.argv.includes("--quiet")) {
-      console.warn(import_picocolors11.default.yellow(`[!] ${message}`));
+      console.warn(import_picocolors16.default.yellow(`[!] ${message}`));
     }
   },
   error: (message) => {
     if (!process.argv.includes("--quiet")) {
-      console.error(import_picocolors11.default.red(`[x] ${message}`));
+      console.error(import_picocolors16.default.red(`[x] ${message}`));
     }
   },
   debug: (message) => {
     if ((process.env.DEBUG || process.argv.includes("--verbose")) && !process.argv.includes("--quiet")) {
-      console.log(import_picocolors11.default.dim(`[DEBUG] ${message}`));
+      console.log(import_picocolors16.default.dim(`[DEBUG] ${message}`));
     }
   },
   verbose: (message) => {
     if (process.argv.includes("--verbose") && !process.argv.includes("--quiet")) {
-      console.log(import_picocolors11.default.dim(message));
+      console.log(import_picocolors16.default.dim(message));
     }
   }
 };
@@ -3787,23 +6013,39 @@ Usage: ock agent <action>
   }
   await agentCommand(action);
 });
-cli.command("skill [action]", "Manage skills (list, add, view)").action(async (action) => {
+cli.command("command [action]", "Manage slash commands (list, create, view, remove)").action(async (action) => {
+  if (!action) {
+    console.log(`
+Usage: ock command <action>
+`);
+    console.log("Actions:");
+    console.log("  list    List all slash commands");
+    console.log("  create  Create a new command");
+    console.log("  view    View command content");
+    console.log(`  remove  Remove a command
+`);
+    return;
+  }
+  await commandCommand(action);
+});
+cli.command("agent [action]", "Manage agents (list, create, view, remove)").action(async (action) => {
   if (!action) {
     console.log(`
-Usage: ock skill <action>
+Usage: ock agent <action>
 `);
     console.log("Actions:");
-    console.log("  list    List all skills");
-    console.log("  add     Install a skill");
-    console.log(`  view    View skill details
+    console.log("  list    List all agents");
+    console.log("  create  Create a new agent");
+    console.log("  view    View agent details");
+    console.log(`  remove  Remove an agent
 `);
     return;
   }
-  await skillCommand(action);
+  await agentCommand(action);
 });
 cli.command("doctor", "Check project health").action(doctorCommand);
 cli.command("status", "Show project overview").action(statusCommand);
-cli.command("config [action]", "Edit opencode.json (model, mcp, permission, keybinds, show)").action(async (action) => {
+cli.command("config [action]", "Edit opencode.json (model, mcp, permission, validate, show)").action(async (action) => {
   await configCommand(action);
 });
 cli.command("upgrade", "Update .opencode/ templates to latest version").option("--force", "Force upgrade even if already up to date").option("--check", "Check for updates without upgrading").action(async (options) => {
@@ -3812,6 +6054,9 @@ cli.command("upgrade", "Update .opencode/ templates to latest version").option("
 cli.command("completion [shell]", "Generate shell completion script (bash, zsh, fish)").action(async (shell) => {
   await completionCommand(shell);
 });
+cli.command("tui", "Launch interactive dashboard").action(async () => {
+  await launchTUI();
+});
 cli.command("", "Interactive menu").action(async () => {
   await interactiveMenu(packageVersion);
 });