opencode-manifold 0.4.11 → 0.4.13

package/dist/index.js

@@ -1,449 +1,114 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/init.ts
-import { readFile, writeFile, mkdir, readdir } from "fs/promises";
+// src/tui.ts
 import { existsSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { join } from "path";
 import { homedir } from "os";
-import { createRequire as createRequire2 } from "module";
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var require2 = createRequire2(import.meta.url);
-var bundledTemplatesDir = join(__dirname2, "..", "src", "templates");
-var globalTemplatesDir = join(homedir(), ".config", "opencode", "manifold");
-async function getPluginVersion() {
-  try {
-    const packageJson = require2(join(__dirname2, "..", "package.json"));
-    return packageJson.version || "unknown";
-  } catch {
-    return "unknown";
-  }
+import { readFile, writeFile, readdir } from "fs/promises";
+
+// node_modules/js-yaml/dist/js-yaml.mjs
+/*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
+function isNothing(subject) {
+  return typeof subject === "undefined" || subject === null;
 }
-async function dirHasContent(dirPath) {
-  if (!existsSync(dirPath))
-    return false;
-  try {
-    const entries = await readdir(dirPath);
-    return entries.length > 0;
-  } catch {
-    return false;
-  }
+function isObject(subject) {
+  return typeof subject === "object" && subject !== null;
 }
-async function copyMissingFiles(src, dest) {
-  if (!existsSync(src))
+function toArray(sequence) {
+  if (Array.isArray(sequence))
+    return sequence;
+  else if (isNothing(sequence))
     return [];
-  await mkdir(dest, { recursive: true });
-  const copied = [];
-  const entries = await readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      const subCopied = await copyMissingFiles(srcPath, destPath);
-      if (subCopied.length > 0) {
-        copied.push(entry.name);
-      }
-    } else if (!existsSync(destPath)) {
-      await writeFile(destPath, await readFile(srcPath));
-      copied.push(entry.name);
-    }
-  }
-  return copied;
+  return [sequence];
 }
-async function ensureGlobalTemplates(ctx) {
-  await ctx.client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: "Checking global templates..."
+function extend(target, source) {
+  var index, length, key, sourceKeys;
+  if (source) {
+    sourceKeys = Object.keys(source);
+    for (index = 0, length = sourceKeys.length;index < length; index += 1) {
+      key = sourceKeys[index];
+      target[key] = source[key];
     }
-  });
-  if (!existsSync(bundledTemplatesDir)) {
-    await ctx.client.app.log({
-      body: {
-        service: "opencode-manifold",
-        level: "error",
-        message: `Bundled templates not found at ${bundledTemplatesDir}`
-      }
-    });
-    return;
   }
-  await copyMissingFiles(bundledTemplatesDir, globalTemplatesDir);
-  const globalCommandsDir = join(homedir(), ".config", "opencode", "commands");
-  const bundledCommandsDir = join(bundledTemplatesDir, "commands");
-  if (existsSync(bundledCommandsDir)) {
-    await copyMissingFiles(bundledCommandsDir, globalCommandsDir);
-  }
-  await ctx.client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: "Global templates ready"
-    }
-  });
+  return target;
 }
-async function initProject(directory, client) {
-  const initialized = [];
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `Running /manifold-init in ${directory}`
-    }
-  });
-  if (!await dirHasContent(globalTemplatesDir)) {
-    await client.app.log({
-      body: {
-        service: "opencode-manifold",
-        level: "error",
-        message: `Global templates not found at ${globalTemplatesDir}. Plugin may not have loaded correctly.`
-      }
-    });
-    return initialized;
-  }
-  const agentsCopied = await copyMissingFiles(join(globalTemplatesDir, "agents"), join(directory, ".opencode", "agents"));
-  if (agentsCopied.length > 0) {
-    initialized.push(`agents (${agentsCopied.join(", ")})`);
+function repeat(string, count) {
+  var result = "", cycle;
+  for (cycle = 0;cycle < count; cycle += 1) {
+    result += string;
   }
-  const skillsCopied = await copyMissingFiles(join(globalTemplatesDir, "skills"), join(directory, ".opencode", "skills"));
-  if (skillsCopied.length > 0) {
-    initialized.push(`skills (${skillsCopied.join(", ")})`);
+  return result;
+}
+function isNegativeZero(number) {
+  return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
+}
+var isNothing_1 = isNothing;
+var isObject_1 = isObject;
+var toArray_1 = toArray;
+var repeat_1 = repeat;
+var isNegativeZero_1 = isNegativeZero;
+var extend_1 = extend;
+var common = {
+  isNothing: isNothing_1,
+  isObject: isObject_1,
+  toArray: toArray_1,
+  repeat: repeat_1,
+  isNegativeZero: isNegativeZero_1,
+  extend: extend_1
+};
+function formatError(exception, compact) {
+  var where = "", message = exception.reason || "(unknown reason)";
+  if (!exception.mark)
+    return message;
+  if (exception.mark.name) {
+    where += 'in "' + exception.mark.name + '" ';
   }
-  const manifoldCopied = await copyMissingFiles(join(globalTemplatesDir, "manifold"), join(directory, "Manifold"));
-  if (manifoldCopied.length > 0) {
-    initialized.push(`Manifold/ (${manifoldCopied.join(", ")})`);
+  where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
+  if (!compact && exception.mark.snippet) {
+    where += `
+
+` + exception.mark.snippet;
   }
-  const version = await getPluginVersion();
-  await writeFile(join(directory, "Manifold", "VERSION"), version + `
-`);
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `/manifold-init complete: ${initialized.join(", ") || "already initialized"}`
-    }
-  });
-  return initialized;
+  return message + " " + where;
 }
-
-// src/tools/dispatch-task.ts
-import { tool } from "@opencode-ai/plugin";
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
-
-// src/state-machine.ts
-import { readFile as readFile3, writeFile as writeFile3, readdir as readdir2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
-
-// src/session-spawner.ts
-async function waitForSessionIdle(client, sessionId, timeoutMs) {
-  const startTime = Date.now();
-  while (Date.now() - startTime < timeoutMs) {
-    const statusResponse = await client.session.status({});
-    const statusData = statusResponse.data;
-    if (statusData && statusData[sessionId]) {
-      const status = statusData[sessionId];
-      if (status.type === "idle") {
-        return true;
-      }
-      if (status.type === "retry") {
-        const waitTime = status.next - Date.now();
-        if (waitTime > 0) {
-          await new Promise((resolve) => setTimeout(resolve, Math.min(waitTime, 1000)));
-        }
-        continue;
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, 500));
+function YAMLException$1(reason, mark) {
+  Error.call(this);
+  this.name = "YAMLException";
+  this.reason = reason;
+  this.mark = mark;
+  this.message = formatError(this, false);
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, this.constructor);
+  } else {
+    this.stack = new Error().stack || "";
   }
-  return false;
 }
-async function getLastAssistantMessage(client, sessionId) {
-  const messagesResponse = await client.session.messages({
-    path: { id: sessionId }
-  });
-  const messages = messagesResponse.data;
-  if (!messages || !Array.isArray(messages)) {
-    return "";
+YAMLException$1.prototype = Object.create(Error.prototype);
+YAMLException$1.prototype.constructor = YAMLException$1;
+YAMLException$1.prototype.toString = function toString(compact) {
+  return this.name + ": " + formatError(this, compact);
+};
+var exception = YAMLException$1;
+function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+  var head = "";
+  var tail = "";
+  var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+  if (position - lineStart > maxHalfLength) {
+    head = " ... ";
+    lineStart = position - maxHalfLength + head.length;
   }
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.info && msg.info.role === "assistant") {
-      if (msg.parts && Array.isArray(msg.parts)) {
-        for (const part of msg.parts) {
-          if (part.type === "text" && part.text) {
-            return part.text;
-          }
-        }
-      }
-    }
+  if (lineEnd - position > maxHalfLength) {
+    tail = " ...";
+    lineEnd = position + maxHalfLength - tail.length;
   }
-  return "";
+  return {
+    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
+    pos: position - lineStart + head.length
+  };
 }
-async function cleanupSession(client, sessionId) {
-  try {
-    await client.session.delete({ path: { id: sessionId } });
-  } catch {}
-}
-async function spawnSession(client, agent, prompt, timeoutSeconds) {
-  const timeoutMs = timeoutSeconds * 1000;
-  try {
-    const createResponse = await client.session.create({});
-    const session = createResponse.data;
-    if (!session || !session.id) {
-      return {
-        content: "",
-        success: false,
-        error: "Failed to create session"
-      };
-    }
-    const sessionId = session.id;
-    await client.app.log({
-      body: {
-        service: "opencode-manifold",
-        level: "info",
-        message: `Created session ${sessionId} for agent ${agent}`
-      }
-    });
-    try {
-      await client.session.promptAsync({
-        path: { id: sessionId },
-        body: {
-          agent,
-          noReply: true,
-          parts: [{ type: "text", text: prompt }]
-        }
-      });
-      const isIdle = await waitForSessionIdle(client, sessionId, timeoutMs);
-      if (!isIdle) {
-        await client.session.abort({ path: { id: sessionId } });
-        return {
-          content: "",
-          success: false,
-          error: `Session timed out after ${timeoutSeconds}s`
-        };
-      }
-      const content = await getLastAssistantMessage(client, sessionId);
-      await client.app.log({
-        body: {
-          service: "opencode-manifold",
-          level: "info",
-          message: `Session ${sessionId} completed, content length: ${content.length}`
-        }
-      });
-      return {
-        content,
-        success: true
-      };
-    } finally {
-      await cleanupSession(client, sessionId);
-    }
-  } catch (error) {
-    return {
-      content: "",
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function spawnClerkSession(client, prompt, agent, timeout) {
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `Spawning Clerk session (agent: ${agent}, timeout: ${timeout}s)`
-    }
-  });
-  return spawnSession(client, agent, prompt, timeout);
-}
-async function spawnSeniorDevSession(client, prompt, agent, timeout) {
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `Spawning Senior Dev session (agent: ${agent}, timeout: ${timeout}s)`
-    }
-  });
-  return spawnSession(client, agent, prompt, timeout);
-}
-async function spawnJuniorDevSession(client, prompt, seniorOutput, agent, timeout) {
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `Spawning Junior Dev session (agent: ${agent}, timeout: ${timeout}s)`
-    }
-  });
-  const fullPrompt = `${prompt}
-
----
-
-Senior Dev's Implementation:
-${seniorOutput}`;
-  return spawnSession(client, agent, fullPrompt, timeout);
-}
-async function spawnDebugSession(client, prompt, loopHistory, agent, timeout) {
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `Spawning Debug session (agent: ${agent}, timeout: ${timeout}s)`
-    }
-  });
-  const fullPrompt = `${prompt}
-
----
-
-Loop History:
-${loopHistory}`;
-  return spawnSession(client, agent, fullPrompt, timeout);
-}
-function parseJuniorFirstWord(response) {
-  const firstWord = response.trim().split(/\s+/)[0].toUpperCase();
-  if (firstWord === "COMPLETE") {
-    return "COMPLETE";
-  }
-  return "QUESTIONS";
-}
-
-// src/error-handler.ts
-class ModelCallError extends Error {
-  agent;
-  attempt;
-  constructor(message, agent, attempt) {
-    super(message);
-    this.agent = agent;
-    this.attempt = attempt;
-    this.name = "ModelCallError";
-  }
-}
-async function retryWithBackoff(fn, options) {
-  let lastError;
-  for (let attempt = 0;attempt <= options.maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (attempt < options.maxRetries) {
-        options.onRetry?.(attempt + 1, lastError);
-        const delay = Math.pow(2, attempt) * 100;
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  }
-  throw lastError;
-}
-
-// src/graph.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
-
-// node_modules/js-yaml/dist/js-yaml.mjs
-/*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
-function isNothing(subject) {
-  return typeof subject === "undefined" || subject === null;
-}
-function isObject(subject) {
-  return typeof subject === "object" && subject !== null;
-}
-function toArray(sequence) {
-  if (Array.isArray(sequence))
-    return sequence;
-  else if (isNothing(sequence))
-    return [];
-  return [sequence];
-}
-function extend(target, source) {
-  var index, length, key, sourceKeys;
-  if (source) {
-    sourceKeys = Object.keys(source);
-    for (index = 0, length = sourceKeys.length;index < length; index += 1) {
-      key = sourceKeys[index];
-      target[key] = source[key];
-    }
-  }
-  return target;
-}
-function repeat(string, count) {
-  var result = "", cycle;
-  for (cycle = 0;cycle < count; cycle += 1) {
-    result += string;
-  }
-  return result;
-}
-function isNegativeZero(number) {
-  return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
-}
-var isNothing_1 = isNothing;
-var isObject_1 = isObject;
-var toArray_1 = toArray;
-var repeat_1 = repeat;
-var isNegativeZero_1 = isNegativeZero;
-var extend_1 = extend;
-var common = {
-  isNothing: isNothing_1,
-  isObject: isObject_1,
-  toArray: toArray_1,
-  repeat: repeat_1,
-  isNegativeZero: isNegativeZero_1,
-  extend: extend_1
-};
-function formatError(exception, compact) {
-  var where = "", message = exception.reason || "(unknown reason)";
-  if (!exception.mark)
-    return message;
-  if (exception.mark.name) {
-    where += 'in "' + exception.mark.name + '" ';
-  }
-  where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
-  if (!compact && exception.mark.snippet) {
-    where += `
-
-` + exception.mark.snippet;
-  }
-  return message + " " + where;
-}
-function YAMLException$1(reason, mark) {
-  Error.call(this);
-  this.name = "YAMLException";
-  this.reason = reason;
-  this.mark = mark;
-  this.message = formatError(this, false);
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, this.constructor);
-  } else {
-    this.stack = new Error().stack || "";
-  }
-}
-YAMLException$1.prototype = Object.create(Error.prototype);
-YAMLException$1.prototype.constructor = YAMLException$1;
-YAMLException$1.prototype.toString = function toString(compact) {
-  return this.name + ": " + formatError(this, compact);
-};
-var exception = YAMLException$1;
-function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
-  var head = "";
-  var tail = "";
-  var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
-  if (position - lineStart > maxHalfLength) {
-    head = " ... ";
-    lineStart = position - maxHalfLength + head.length;
-  }
-  if (lineEnd - position > maxHalfLength) {
-    tail = " ...";
-    lineEnd = position + maxHalfLength - tail.length;
-  }
-  return {
-    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
-    pos: position - lineStart + head.length
-  };
-}
-function padStart(string, max) {
-  return common.repeat(" ", max - string.length) + string;
+function padStart(string, max) {
+  return common.repeat(" ", max - string.length) + string;
 }
 function makeSnippet(mark, options) {
   options = Object.create(options || null);
@@ -3027,7 +2692,599 @@ var jsYaml = {
   safeDump
 };
 
+// src/tui.ts
+var MANIFOLD_AGENTS = ["clerk", "senior-dev", "junior-dev", "debug"];
+async function getManifoldAgents(directory) {
+  const agentsDir = join(directory, ".opencode", "agents");
+  if (!existsSync(agentsDir)) {
+    return [];
+  }
+  const files = await readdir(agentsDir);
+  const agents = [];
+  for (const file of files) {
+    if (!file.endsWith(".md"))
+      continue;
+    const name = file.replace(".md", "");
+    if (MANIFOLD_AGENTS.includes(name)) {
+      agents.push(name);
+    }
+  }
+  return agents;
+}
+async function readAgentFile(agentName, directory) {
+  const agentPath = join(directory, ".opencode", "agents", `${agentName}.md`);
+  if (!existsSync(agentPath)) {
+    const globalPath = join(homedir(), ".config", "opencode", "manifold", "agents", `${agentName}.md`);
+    if (existsSync(globalPath)) {
+      const content2 = await readFile(globalPath, "utf-8");
+      const { frontmatter: frontmatter2, body: body2 } = parseFrontmatter(content2);
+      return { content: content2, frontmatter: frontmatter2, body: body2 };
+    }
+    throw new Error(`Agent file not found for ${agentName}`);
+  }
+  const content = await readFile(agentPath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+  return { content, frontmatter, body };
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const frontmatterYaml = match[1];
+  const body = match[2];
+  const frontmatter = jsYaml.load(frontmatterYaml) || {};
+  return { frontmatter, body };
+}
+function buildAgentFile(frontmatter, body) {
+  const yamlContent = jsYaml.dump(frontmatter, {
+    lineWidth: -1,
+    noCompatMode: true
+  });
+  return `---
+${yamlContent}---
+${body}`;
+}
+async function updateAgentModel(agentName, modelId, directory) {
+  const { frontmatter, body } = await readAgentFile(agentName, directory);
+  frontmatter.model = modelId;
+  const newContent = buildAgentFile(frontmatter, body);
+  const agentPath = join(directory, ".opencode", "agents", `${agentName}.md`);
+  await writeFile(agentPath, newContent);
+}
+var tui = async (api) => {
+  api.command.register(() => [
+    {
+      title: "Manifold Models",
+      value: "manifold-models",
+      description: "Set the model for a Manifold sub-agent",
+      category: "Manifold",
+      slash: {
+        name: "manifold-models"
+      }
+    },
+    {
+      title: "Manifold Update",
+      value: "manifold-update",
+      description: "Clear opencode-manifold plugin cache and prompt for restart",
+      category: "Manifold",
+      slash: {
+        name: "manifold-update"
+      }
+    }
+  ]);
+  api.event.on("tui.command.execute", async (event) => {
+    if (event.properties.command === "manifold-models") {
+      await handleManifoldModels(api);
+    } else if (event.properties.command === "manifold-update") {
+      await handleManifoldUpdate(api);
+    }
+  });
+};
+async function handleManifoldModels(api) {
+  const directory = api.state.path.directory;
+  const agents = await getManifoldAgents(directory);
+  if (agents.length === 0) {
+    api.ui.toast({
+      variant: "error",
+      message: "No Manifold agents found. Run /manifold-init first."
+    });
+    return;
+  }
+  const providers = api.state.provider;
+  const models = [];
+  for (const provider of providers) {
+    if (provider.models) {
+      for (const [modelId, model] of Object.entries(provider.models)) {
+        models.push({
+          id: `${provider.id}/${modelId}`,
+          name: model.name || modelId,
+          providerID: provider.id
+        });
+      }
+    }
+  }
+  if (models.length === 0) {
+    api.ui.toast({
+      variant: "error",
+      message: "No models available. Configure providers first."
+    });
+    return;
+  }
+  models.sort((a, b) => a.name.localeCompare(b.name));
+  const agentOptions = agents.map((agent) => ({
+    title: `${agent} (sub-agent)`,
+    value: agent,
+    description: `Configure model for ${agent}`
+  }));
+  api.ui.dialog.setSize("medium");
+  return new Promise((resolve) => {
+    api.ui.ui.DialogSelect({
+      title: "Select Manifold Sub-Agent",
+      options: agentOptions,
+      onSelect: async (option) => {
+        const selectedAgent = option.value;
+        const currentModel = await readAgentFile(selectedAgent, directory).then((f) => f.frontmatter.model || "not set").catch(() => "not set");
+        const modelOptions = models.map((model) => ({
+          title: `${model.name}`,
+          value: model.id,
+          description: model.id,
+          footer: model.id === currentModel ? "✓ Current" : undefined
+        }));
+        api.ui.ui.DialogSelect({
+          title: `Select Model for ${selectedAgent}`,
+          options: modelOptions,
+          current: currentModel !== "not set" ? currentModel : undefined,
+          onSelect: async (modelOption) => {
+            const selectedModelId = modelOption.value;
+            await updateAgentModel(selectedAgent, selectedModelId, directory);
+            api.ui.toast({
+              variant: "success",
+              message: `Set ${selectedAgent} to ${selectedModelId}`
+            });
+            resolve();
+          }
+        });
+      }
+    });
+  });
+}
+async function handleManifoldUpdate(api) {
+  const directory = api.state.path.directory;
+  const settingsPath = join(directory, "Manifold", "settings.json");
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    const content = await readFile(settingsPath, "utf-8");
+    try {
+      settings = JSON.parse(content);
+    } catch {}
+  }
+  const configuredPaths = settings.updateCachePaths || [];
+  if (configuredPaths.length === 0) {
+    api.ui.dialog.setSize("large");
+    api.ui.ui.DialogSelect({
+      title: "Manifold Plugin Update",
+      options: [
+        {
+          title: "Configure Cache Paths",
+          value: "configure",
+          description: "Add updateCachePaths to Manifold/settings.json",
+          footer: "Opens settings file"
+        }
+      ],
+      onSelect: () => {
+        api.ui.toast({
+          variant: "info",
+          message: "Add updateCachePaths to Manifold/settings.json"
+        });
+      }
+    });
+    return;
+  }
+  const resolvedPaths = configuredPaths.map((p) => {
+    const expanded = p.startsWith("~") ? join(homedir(), p.slice(1)) : p;
+    return expanded;
+  });
+  api.ui.dialog.setSize("large");
+  return new Promise((resolve) => {
+    api.ui.ui.DialogSelect({
+      title: "Manifold Plugin Update",
+      options: [
+        {
+          title: "Clear Cache",
+          value: "confirm",
+          description: `Will clear ${resolvedPaths.length} path(s)`,
+          footer: resolvedPaths.map((p) => `• ${p}`).join(`
+`)
+        },
+        {
+          title: "Cancel",
+          value: "cancel",
+          description: "Do not clear cache"
+        }
+      ],
+      onSelect: async (option) => {
+        if (option.value === "cancel") {
+          resolve();
+          return;
+        }
+        const { exec } = await import("child_process");
+        const { promisify } = await import("util");
+        const execAsync = promisify(exec);
+        const cleared = [];
+        const skipped = [];
+        const blocked = [];
+        for (const pathStr of resolvedPaths) {
+          try {
+            await execAsync(`rm -rf "${pathStr}"`);
+            cleared.push(pathStr);
+          } catch (error) {
+            blocked.push({ path: pathStr, reason: `Failed to delete: ${error}` });
+          }
+        }
+        let message = "";
+        if (cleared.length > 0) {
+          message += `✅ Cleared: ${cleared.length} path(s)
+`;
+        }
+        if (blocked.length > 0) {
+          message += `\uD83D\uDEAB Blocked: ${blocked.length} path(s)
+`;
+        }
+        if (cleared.length > 0) {
+          message += `
+Restart opencode to pull the latest plugin version.`;
+        }
+        api.ui.toast({
+          variant: cleared.length > 0 ? "success" : "error",
+          message: cleared.length > 0 ? `Cache cleared. Restart opencode to update.` : `Cache update blocked`
+        });
+        resolve();
+      }
+    });
+  });
+}
+
+// src/init.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir, readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir as homedir2 } from "os";
+import { createRequire as createRequire2 } from "module";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var require2 = createRequire2(import.meta.url);
+var bundledTemplatesDir = join2(__dirname2, "..", "src", "templates");
+var globalTemplatesDir = join2(homedir2(), ".config", "opencode", "manifold");
+async function getPluginVersion() {
+  try {
+    const packageJson = require2(join2(__dirname2, "..", "package.json"));
+    return packageJson.version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function dirHasContent(dirPath) {
+  if (!existsSync2(dirPath))
+    return false;
+  try {
+    const entries = await readdir2(dirPath);
+    return entries.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function copyFiles(src, dest) {
+  if (!existsSync2(src))
+    return [];
+  await mkdir(dest, { recursive: true });
+  const copied = [];
+  const entries = await readdir2(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join2(src, entry.name);
+    const destPath = join2(dest, entry.name);
+    if (entry.isDirectory()) {
+      const subCopied = await copyFiles(srcPath, destPath);
+      if (subCopied.length > 0) {
+        copied.push(entry.name);
+      }
+    } else {
+      await writeFile2(destPath, await readFile2(srcPath));
+      copied.push(entry.name);
+    }
+  }
+  return copied;
+}
+async function ensureGlobalTemplates(ctx) {
+  await ctx.client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: "Synchronizing global templates..."
+    }
+  });
+  if (!existsSync2(bundledTemplatesDir)) {
+    await ctx.client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "error",
+        message: `Bundled templates not found at ${bundledTemplatesDir}`
+      }
+    });
+    return;
+  }
+  await copyFiles(bundledTemplatesDir, globalTemplatesDir);
+  const globalCommandsDir = join2(homedir2(), ".config", "opencode", "commands");
+  const bundledCommandsDir = join2(bundledTemplatesDir, "commands");
+  if (existsSync2(bundledCommandsDir)) {
+    await copyFiles(bundledCommandsDir, globalCommandsDir);
+  }
+  await ctx.client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: "Global templates synchronized"
+    }
+  });
+}
+async function initProject(directory, client) {
+  const initialized = [];
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Running /manifold-init in ${directory}`
+    }
+  });
+  if (!await dirHasContent(globalTemplatesDir)) {
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "error",
+        message: `Global templates not found at ${globalTemplatesDir}. Plugin may not have loaded correctly.`
+      }
+    });
+    return initialized;
+  }
+  const agentsCopied = await copyMissingFiles(join2(globalTemplatesDir, "agents"), join2(directory, ".opencode", "agents"));
+  if (agentsCopied.length > 0) {
+    initialized.push(`agents (${agentsCopied.join(", ")})`);
+  }
+  const skillsCopied = await copyMissingFiles(join2(globalTemplatesDir, "skills"), join2(directory, ".opencode", "skills"));
+  if (skillsCopied.length > 0) {
+    initialized.push(`skills (${skillsCopied.join(", ")})`);
+  }
+  const manifoldCopied = await copyMissingFiles(join2(globalTemplatesDir, "manifold"), join2(directory, "Manifold"));
+  if (manifoldCopied.length > 0) {
+    initialized.push(`Manifold/ (${manifoldCopied.join(", ")})`);
+  }
+  const version = await getPluginVersion();
+  await writeFile2(join2(directory, "Manifold", "VERSION"), version + `
+`);
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `/manifold-init complete: ${initialized.join(", ") || "already initialized"}`
+    }
+  });
+  return initialized;
+}
+
+// src/tools/dispatch-task.ts
+import { tool } from "@opencode-ai/plugin";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+
+// src/state-machine.ts
+import { readFile as readFile4, writeFile as writeFile4, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+
+// src/session-spawner.ts
+async function waitForSessionIdle(client, sessionId, timeoutMs) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    const statusResponse = await client.session.status({});
+    const statusData = statusResponse.data;
+    if (statusData && statusData[sessionId]) {
+      const status = statusData[sessionId];
+      if (status.type === "idle") {
+        return true;
+      }
+      if (status.type === "retry") {
+        const waitTime = status.next - Date.now();
+        if (waitTime > 0) {
+          await new Promise((resolve) => setTimeout(resolve, Math.min(waitTime, 1000)));
+        }
+        continue;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  return false;
+}
+async function getLastAssistantMessage(client, sessionId) {
+  const messagesResponse = await client.session.messages({
+    path: { id: sessionId }
+  });
+  const messages = messagesResponse.data;
+  if (!messages || !Array.isArray(messages)) {
+    return "";
+  }
+  for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+    const msg = messages[i2];
+    if (msg.info && msg.info.role === "assistant") {
+      if (msg.parts && Array.isArray(msg.parts)) {
+        for (const part of msg.parts) {
+          if (part.type === "text" && part.text) {
+            return part.text;
+          }
+        }
+      }
+    }
+  }
+  return "";
+}
+async function cleanupSession(client, sessionId) {
+  try {
+    await client.session.delete({ path: { id: sessionId } });
+  } catch {}
+}
+async function spawnSession(client, agent, prompt, timeoutSeconds) {
+  const timeoutMs = timeoutSeconds * 1000;
+  try {
+    const createResponse = await client.session.create({});
+    const session = createResponse.data;
+    if (!session || !session.id) {
+      return {
+        content: "",
+        success: false,
+        error: "Failed to create session"
+      };
+    }
+    const sessionId = session.id;
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `Created session ${sessionId} for agent ${agent}`
+      }
+    });
+    try {
+      await client.session.promptAsync({
+        path: { id: sessionId },
+        body: {
+          agent,
+          noReply: true,
+          parts: [{ type: "text", text: prompt }]
+        }
+      });
+      const isIdle = await waitForSessionIdle(client, sessionId, timeoutMs);
+      if (!isIdle) {
+        await client.session.abort({ path: { id: sessionId } });
+        return {
+          content: "",
+          success: false,
+          error: `Session timed out after ${timeoutSeconds}s`
+        };
+      }
+      const content = await getLastAssistantMessage(client, sessionId);
+      await client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "info",
+          message: `Session ${sessionId} completed, content length: ${content.length}`
+        }
+      });
+      return {
+        content,
+        success: true
+      };
+    } finally {
+      await cleanupSession(client, sessionId);
+    }
+  } catch (error) {
+    return {
+      content: "",
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function spawnClerkSession(client, prompt, agent, timeout) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Spawning Clerk session (agent: ${agent}, timeout: ${timeout}s)`
+    }
+  });
+  return spawnSession(client, agent, prompt, timeout);
+}
+async function spawnSeniorDevSession(client, prompt, agent, timeout) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Spawning Senior Dev session (agent: ${agent}, timeout: ${timeout}s)`
+    }
+  });
+  return spawnSession(client, agent, prompt, timeout);
+}
+async function spawnJuniorDevSession(client, prompt, seniorOutput, agent, timeout) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Spawning Junior Dev session (agent: ${agent}, timeout: ${timeout}s)`
+    }
+  });
+  const fullPrompt = `${prompt}
+
+---
+
+Senior Dev's Implementation:
+${seniorOutput}`;
+  return spawnSession(client, agent, fullPrompt, timeout);
+}
+async function spawnDebugSession(client, prompt, loopHistory, agent, timeout) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Spawning Debug session (agent: ${agent}, timeout: ${timeout}s)`
+    }
+  });
+  const fullPrompt = `${prompt}
+
+---
+
+Loop History:
+${loopHistory}`;
+  return spawnSession(client, agent, fullPrompt, timeout);
+}
+function parseJuniorFirstWord(response) {
+  const firstWord = response.trim().split(/\s+/)[0].toUpperCase();
+  if (firstWord === "COMPLETE") {
+    return "COMPLETE";
+  }
+  return "QUESTIONS";
+}
+
+// src/error-handler.ts
+class ModelCallError extends Error {
+  agent;
+  attempt;
+  constructor(message, agent, attempt) {
+    super(message);
+    this.agent = agent;
+    this.attempt = attempt;
+    this.name = "ModelCallError";
+  }
+}
+async function retryWithBackoff(fn, options) {
+  let lastError;
+  for (let attempt = 0;attempt <= options.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < options.maxRetries) {
+        options.onRetry?.(attempt + 1, lastError);
+        const delay = Math.pow(2, attempt) * 100;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+
 // src/graph.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
 var ENCODE_MAP = { "/": "__SL__", ".": "__DT__" };
 var ENCODE_RE = /[/.]/g;
 function pathToGraphFilename(filePath) {
@@ -3137,12 +3394,12 @@ ${tasksSection}
 }
 async function readGraphFile(directory, filePath) {
   const filename = pathToGraphFilename(filePath);
-  const graphPath = join2(directory, "Manifold", "graph", filename);
-  if (!existsSync2(graphPath)) {
+  const graphPath = join3(directory, "Manifold", "graph", filename);
+  if (!existsSync3(graphPath)) {
     return null;
   }
   try {
-    const content = await readFile2(graphPath, "utf-8");
+    const content = await readFile3(graphPath, "utf-8");
     return parseGraphContent(content);
   } catch {
     return null;
@@ -3150,9 +3407,9 @@ async function readGraphFile(directory, filePath) {
 }
 async function updateGraphFile(directory, filePath, taskId, calls, dependsOn) {
   const filename = pathToGraphFilename(filePath);
-  const graphPath = join2(directory, "Manifold", "graph", filename);
+  const graphPath = join3(directory, "Manifold", "graph", filename);
   let entry;
-  if (existsSync2(graphPath)) {
+  if (existsSync3(graphPath)) {
     const existing = await readGraphFile(directory, filePath);
     entry = existing || {
       filePath,
@@ -3178,11 +3435,11 @@ async function updateGraphFile(directory, filePath, taskId, calls, dependsOn) {
     entry.tasksThatEdited.push(taskId);
   }
   const graphDir = dirname2(graphPath);
-  if (!existsSync2(graphDir)) {
+  if (!existsSync3(graphDir)) {
     await mkdir2(graphDir, { recursive: true });
   }
   const content = formatGraphContent(entry);
-  await writeFile2(graphPath, content, "utf-8");
+  await writeFile3(graphPath, content, "utf-8");
 }
 async function updateGraphFilesForTask(directory, taskId, files) {
   for (const file of files) {
@@ -3195,9 +3452,9 @@ async function updateGraphFilesForTask(directory, taskId, files) {
 }
 async function replaceGraphCalls(directory, filePath, calls, dependsOn) {
   const filename = pathToGraphFilename(filePath);
-  const graphPath = join2(directory, "Manifold", "graph", filename);
+  const graphPath = join3(directory, "Manifold", "graph", filename);
   let entry;
-  if (existsSync2(graphPath)) {
+  if (existsSync3(graphPath)) {
     const existing = await readGraphFile(directory, filePath);
     entry = existing || {
       filePath,
@@ -3216,20 +3473,20 @@ async function replaceGraphCalls(directory, filePath, calls, dependsOn) {
   entry.calls = [...new Set(calls)];
   entry.dependsOn = [...new Set(dependsOn)];
   const graphDir = dirname2(graphPath);
-  if (!existsSync2(graphDir)) {
+  if (!existsSync3(graphDir)) {
     await mkdir2(graphDir, { recursive: true });
   }
   const content = formatGraphContent(entry);
-  await writeFile2(graphPath, content, "utf-8");
+  await writeFile3(graphPath, content, "utf-8");
 }
 
 // src/graph-sync.ts
 import Database from "better-sqlite3";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 function openIndexDb(projectRoot) {
-  const dbPath = join3(projectRoot, ".opencode", "index", "codebase.db");
-  if (!existsSync3(dbPath)) {
+  const dbPath = join4(projectRoot, ".opencode", "index", "codebase.db");
+  if (!existsSync4(dbPath)) {
     return null;
   }
   try {
@@ -3317,9 +3574,9 @@ async function syncGraphFilesFromIndex(projectRoot, files) {
 
 // src/state-machine.ts
 async function readState(directory) {
-  const statePath = join4(directory, "Manifold", "state.json");
-  if (existsSync4(statePath)) {
-    const content = await readFile3(statePath, "utf-8");
+  const statePath = join5(directory, "Manifold", "state.json");
+  if (existsSync5(statePath)) {
+    const content = await readFile4(statePath, "utf-8");
     return JSON.parse(content);
   }
   return {
@@ -3335,8 +3592,8 @@ async function readState(directory) {
   };
 }
 async function writeState(directory, state) {
-  const statePath = join4(directory, "Manifold", "state.json");
-  await writeFile3(statePath, JSON.stringify(state, null, 2));
+  const statePath = join5(directory, "Manifold", "state.json");
+  await writeFile4(statePath, JSON.stringify(state, null, 2));
 }
 function buildLoopHistory(state) {
   if (state.loop_history.length === 0) {
@@ -3348,16 +3605,16 @@ ${entry}`).join(`
 `);
 }
 async function readRecentTaskLogs(directory, count) {
-  const tasksDir = join4(directory, "Manifold", "tasks");
-  if (!existsSync4(tasksDir)) {
+  const tasksDir = join5(directory, "Manifold", "tasks");
+  if (!existsSync5(tasksDir)) {
     return [];
   }
   try {
-    const files = await readdir2(tasksDir);
+    const files = await readdir3(tasksDir);
     const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
     const recentFiles = mdFiles.slice(-count);
     const tasks = await Promise.all(recentFiles.map(async (filename) => {
-      const content = await readFile3(join4(tasksDir, filename), "utf-8");
+      const content = await readFile4(join5(tasksDir, filename), "utf-8");
       return { filename, content };
     }));
     return tasks;
@@ -4065,9 +4322,9 @@ function setPluginContext(client) {
   pluginClient = client;
 }
 async function readSettings(directory) {
-  const settingsPath = join5(directory, "Manifold", "settings.json");
-  if (existsSync5(settingsPath)) {
-    const content = await readFile4(settingsPath, "utf-8");
+  const settingsPath = join6(directory, "Manifold", "settings.json");
+  if (existsSync6(settingsPath)) {
+    const content = await readFile5(settingsPath, "utf-8");
     return JSON.parse(content);
   }
   return {
@@ -4082,10 +4339,10 @@ async function readSettings(directory) {
   };
 }
 async function updatePlansRegistry(directory, planFile) {
-  const plansPath = join5(directory, "Manifold", "plans.json");
+  const plansPath = join6(directory, "Manifold", "plans.json");
   let plans = {};
-  if (existsSync5(plansPath)) {
-    const content = await readFile4(plansPath, "utf-8");
+  if (existsSync6(plansPath)) {
+    const content = await readFile5(plansPath, "utf-8");
     plans = JSON.parse(content);
   }
   const planSlug = planFile.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase().substring(0, 30);
@@ -4099,7 +4356,7 @@ async function updatePlansRegistry(directory, planFile) {
     };
   }
   plans[planSlug].task_count++;
-  await writeFile4(plansPath, JSON.stringify(plans, null, 2));
+  await writeFile5(plansPath, JSON.stringify(plans, null, 2));
   return plans[planSlug].task_count;
 }
 function getClient() {
@@ -4195,484 +4452,6 @@ ${testResult.result.output}`,
   }
 });
 
-// src/tools/set-subagent-model.ts
-import { readFile as readFile5, writeFile as writeFile5, readdir as readdir3 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir2 } from "os";
-var MANIFOLD_AGENTS = ["clerk", "senior-dev", "junior-dev", "debug"];
-async function getManifoldAgents(directory) {
-  const agentsDir = join6(directory, ".opencode", "agents");
-  if (!existsSync6(agentsDir)) {
-    return [];
-  }
-  const files = await readdir3(agentsDir);
-  const agents = [];
-  for (const file of files) {
-    if (!file.endsWith(".md"))
-      continue;
-    const name = file.replace(".md", "");
-    if (MANIFOLD_AGENTS.includes(name)) {
-      agents.push(name);
-    }
-  }
-  return agents;
-}
-async function getAvailableModels(client) {
-  try {
-    const result = await client.config.providers();
-    const providers = result.data?.providers || [];
-    const models = [];
-    for (const provider of providers) {
-      if (provider.models) {
-        for (const [modelId, model] of Object.entries(provider.models)) {
-          models.push({
-            id: `${provider.id}/${modelId}`,
-            name: model.name || modelId,
-            providerID: provider.id
-          });
-        }
-      }
-    }
-    return models.sort((a, b) => a.name.localeCompare(b.name));
-  } catch (error) {
-    await client.app.log({
-      body: {
-        service: "opencode-manifold",
-        level: "error",
-        message: `Error fetching models: ${error}`
-      }
-    });
-    return [];
-  }
-}
-async function readAgentFile(agentName, directory) {
-  const agentPath = join6(directory, ".opencode", "agents", `${agentName}.md`);
-  if (!existsSync6(agentPath)) {
-    const globalPath = join6(homedir2(), ".config", "opencode", "manifold", "agents", `${agentName}.md`);
-    if (existsSync6(globalPath)) {
-      const content2 = await readFile5(globalPath, "utf-8");
-      const { frontmatter: frontmatter2, body: body2 } = parseFrontmatter(content2);
-      return { content: content2, frontmatter: frontmatter2, body: body2 };
-    }
-    throw new Error(`Agent file not found for ${agentName}`);
-  }
-  const content = await readFile5(agentPath, "utf-8");
-  const { frontmatter, body } = parseFrontmatter(content);
-  return { content, frontmatter, body };
-}
-function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match) {
-    return { frontmatter: {}, body: content };
-  }
-  const frontmatterYaml = match[1];
-  const body = match[2];
-  const frontmatter = jsYaml.load(frontmatterYaml) || {};
-  return { frontmatter, body };
-}
-function buildAgentFile(frontmatter, body) {
-  const yamlContent = jsYaml.dump(frontmatter, {
-    lineWidth: -1,
-    noCompatMode: true
-  });
-  return `---
-${yamlContent}---
-${body}`;
-}
-async function updateAgentModel(client, agentName, modelId, directory) {
-  const { frontmatter, body } = await readAgentFile(agentName, directory);
-  frontmatter.model = modelId;
-  const newContent = buildAgentFile(frontmatter, body);
-  const agentPath = join6(directory, ".opencode", "agents", `${agentName}.md`);
-  await writeFile5(agentPath, newContent);
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `Updated ${agentName} model to ${modelId}`
-    }
-  });
-}
-async function handleSubModelCommand(client, directory) {
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: "Starting /sub-model command"
-    }
-  });
-  const agents = await getManifoldAgents(directory);
-  if (agents.length === 0) {
-    await client.tui.showToast({
-      body: {
-        type: "error",
-        message: "No Manifold agents found. Run /manifold-init first."
-      }
-    });
-    return;
-  }
-  const models = await getAvailableModels(client);
-  if (models.length === 0) {
-    await client.tui.showToast({
-      body: {
-        type: "error",
-        message: "No models available. Configure providers first."
-      }
-    });
-    return;
-  }
-  const agentList = agents.map((a) => `${a} (sub-agent)`).join(`
-`);
-  await client.tui.appendPrompt({
-    body: {
-      type: "text",
-      text: `\uD83D\uDCCB Select a Manifold sub-agent to configure:
-
-${agentList}`
-    }
-  });
-  await client.tui.publish({
-    body: {
-      type: "tui.prompt_append",
-      data: {
-        type: "text",
-        text: `
-
-Type the agent name (clerk, senior-dev, junior-dev, or debug): `
-      }
-    }
-  });
-  const agentResponse = await client.tui.control.next();
-  const selectedAgent = agentResponse.data?.input?.trim().toLowerCase();
-  if (!selectedAgent || !MANIFOLD_AGENTS.includes(selectedAgent)) {
-    await client.tui.showToast({
-      body: {
-        type: "error",
-        message: `Invalid agent selection. Must be one of: ${MANIFOLD_AGENTS.join(", ")}`
-      }
-    });
-    return;
-  }
-  if (!agents.includes(selectedAgent)) {
-    await client.tui.showToast({
-      body: {
-        type: "error",
-        message: `Agent ${selectedAgent} not found in .opencode/agents/`
-      }
-    });
-    return;
-  }
-  const currentModel = await readAgentFile(selectedAgent, directory).then((f) => f.frontmatter.model || "not set");
-  const modelList = models.map((m, i2) => `${i2 + 1}. ${m.name} (${m.id})`).join(`
-`);
-  await client.tui.appendPrompt({
-    body: {
-      type: "text",
-      text: `
-\uD83D\uDCE6 Available models for ${selectedAgent} (current: ${currentModel}):
-
-${modelList}`
-    }
-  });
-  await client.tui.publish({
-    body: {
-      type: "tui.prompt_append",
-      data: {
-        type: "text",
-        text: `
-
-Type the model number or full model ID (e.g., anthropic/claude-sonnet-4-20250514): `
-      }
-    }
-  });
-  const modelResponse = await client.tui.control.next();
-  const selectedModelInput = modelResponse.data?.input?.trim();
-  if (!selectedModelInput) {
-    await client.tui.showToast({
-      body: {
-        type: "error",
-        message: "No model selected"
-      }
-    });
-    return;
-  }
-  let selectedModelId;
-  const modelIndex = parseInt(selectedModelInput, 10) - 1;
-  if (!isNaN(modelIndex) && modelIndex >= 0 && modelIndex < models.length) {
-    selectedModelId = models[modelIndex].id;
-  } else {
-    const found = models.find((m) => m.id.toLowerCase() === selectedModelInput.toLowerCase());
-    if (found) {
-      selectedModelId = found.id;
-    }
-  }
-  if (!selectedModelId) {
-    await client.tui.showToast({
-      body: {
-        type: "error",
-        message: `Invalid model selection: ${selectedModelInput}`
-      }
-    });
-    return;
-  }
-  await updateAgentModel(client, selectedAgent, selectedModelId, directory);
-  await client.tui.showToast({
-    body: {
-      type: "success",
-      message: `✅ Set ${selectedAgent} to ${selectedModelId}`
-    }
-  });
-  await client.tui.appendPrompt({
-    body: {
-      type: "text",
-      text: `
-✅ Model updated for ${selectedAgent}: ${selectedModelId}
-`
-    }
-  });
-}
-
-// src/tools/clear-cache.ts
-import { rm } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { join as join7, isAbsolute } from "path";
-import { homedir as homedir3 } from "os";
-var PROTECTED_PATHS = [
-  "/",
-  "/System",
-  "/Applications",
-  "/Users",
-  "/etc",
-  "/bin",
-  "/sbin",
-  "/usr"
-];
-function resolvePath(pathStr) {
-  const expanded = pathStr.startsWith("~") ? join7(homedir3(), pathStr.slice(1)) : pathStr;
-  return isAbsolute(expanded) ? expanded : join7(process.cwd(), expanded);
-}
-function isPathSafe(pathStr) {
-  const normalized = pathStr.toLowerCase();
-  if (normalized.includes("*")) {
-    return { safe: false, reason: "Wildcards are not allowed for safety" };
-  }
-  for (const protectedPath of PROTECTED_PATHS) {
-    if (normalized === protectedPath.toLowerCase() || normalized.startsWith(protectedPath.toLowerCase() + "/") || normalized.startsWith(protectedPath.toLowerCase() + "\\")) {
-      return { safe: false, reason: `Cannot delete protected system path: ${protectedPath}` };
-    }
-  }
-  if (normalized === homedir3().toLowerCase() || normalized.startsWith(homedir3().toLowerCase() + "/") && !normalized.includes("cache") && !normalized.includes("node_modules")) {
-    const parts = normalized.replace(homedir3().toLowerCase(), "").split(/[\/\\]/).filter(Boolean);
-    if (parts.length === 1) {
-      return { safe: false, reason: "Cannot delete directories directly in home folder" };
-    }
-  }
-  return { safe: true };
-}
-async function isProjectDirectory(pathStr) {
-  try {
-    const hasGit = existsSync7(join7(pathStr, ".git"));
-    const hasOpencodeConfig = existsSync7(join7(pathStr, "opencode.json"));
-    const hasPackageJson = existsSync7(join7(pathStr, "package.json"));
-    if (hasGit && (hasOpencodeConfig || hasPackageJson)) {
-      return true;
-    }
-    const entries = await Promise.all([
-      existsSync7(join7(pathStr, ".git")) ? "git" : null,
-      existsSync7(join7(pathStr, "opencode.json")) ? "opencode" : null
-    ].filter(Boolean));
-    return entries.length >= 2;
-  } catch {
-    return false;
-  }
-}
-async function clearCachePaths(paths) {
-  const cleared = [];
-  const skipped = [];
-  const blocked = [];
-  for (const pathStr of paths) {
-    const resolved = resolvePath(pathStr);
-    const safetyCheck = isPathSafe(resolved);
-    if (!safetyCheck.safe) {
-      blocked.push({ path: resolved, reason: safetyCheck.reason || "Failed safety check" });
-      continue;
-    }
-    if (!existsSync7(resolved)) {
-      skipped.push(resolved);
-      continue;
-    }
-    const isProject = await isProjectDirectory(resolved);
-    if (isProject) {
-      blocked.push({ path: resolved, reason: "Appears to be a project directory (contains .git + config files)" });
-      continue;
-    }
-    try {
-      await rm(resolved, { recursive: true, force: true });
-      cleared.push(resolved);
-    } catch (error) {
-      blocked.push({ path: resolved, reason: `Failed to delete: ${error}` });
-    }
-  }
-  return { cleared, skipped, blocked };
-}
-async function handleUpdateCommand(client, directory) {
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: "Starting /manifold-update command"
-    }
-  });
-  const settings = await readSettings(directory);
-  const configuredPaths = settings.updateCachePaths || [];
-  if (configuredPaths.length === 0) {
-    const examplePaths = [
-      "~/.cache/opencode/packages/opencode-manifold@latest",
-      "~/node_modules/opencode-manifold"
-    ];
-    await client.tui.appendPrompt({
-      body: {
-        type: "text",
-        text: `\uD83D\uDD04 **Manifold Plugin Update**
-
-No cache paths configured in \`Manifold/settings.json\`.
-
-To enable this feature, add cache paths to your settings:
-
-\`\`\`json
-{
-  "updateCachePaths": [
-    "~/.cache/opencode/packages/opencode-manifold@latest",
-    "~/node_modules/opencode-manifold"
-  ]
-}
-\`\`\`
-
-**Safety features:**
-• Wildcards are blocked
-• System directories are protected
-• Project directories (with .git + config) are protected
-
-**macOS users:** The paths above are typical cache locations.
-**Linux/Windows users:** Add your opencode cache paths manually.
-`
-      }
-    });
-    await client.tui.showToast({
-      body: {
-        type: "info",
-        message: "Configure updateCachePaths in Manifold/settings.json"
-      }
-    });
-    return;
-  }
-  const resolvedPaths = configuredPaths.map(resolvePath);
-  await client.tui.appendPrompt({
-    body: {
-      type: "text",
-      text: `\uD83D\uDD04 **Manifold Plugin Update**
-
-The following paths will be cleared:
-
-${resolvedPaths.map((p) => `• ${p}`).join(`
-`)}
-
-⚠️ **This action is irreversible.** These paths are read from \`Manifold/settings.json\`.
-`
-    }
-  });
-  await client.tui.publish({
-    body: {
-      type: "tui.prompt_append",
-      data: {
-        type: "text",
-        text: `
-
-Type 'yes' to confirm and clear cache: `
-      }
-    }
-  });
-  const response = await client.tui.control.next();
-  const answer = response.data?.input?.trim().toLowerCase();
-  if (answer !== "yes" && answer !== "y") {
-    await client.tui.appendPrompt({
-      body: {
-        type: "text",
-        text: `
-❌ Cancelled. No cache cleared.
-`
-      }
-    });
-    return;
-  }
-  const { cleared, skipped, blocked } = await clearCachePaths(configuredPaths);
-  let message = `
-`;
-  if (cleared.length > 0) {
-    message += `✅ **Cleared:**
-${cleared.map((p) => `• ${p}`).join(`
-`)}
-
-`;
-  }
-  if (skipped.length > 0) {
-    message += `⏭️ **Already clean / skipped:**
-${skipped.map((p) => `• ${p}`).join(`
-`)}
-
-`;
-  }
-  if (blocked.length > 0) {
-    message += `\uD83D\uDEAB **Blocked (safety check):**
-`;
-    for (const item of blocked) {
-      message += `• ${item.path}
-  Reason: ${item.reason}
-`;
-    }
-    message += `
-`;
-  }
-  if (cleared.length > 0) {
-    message += `**Next step:** Restart opencode to pull the latest plugin version.
-
-Your project files (.opencode/, Manifold/) are untouched — only the configured cache paths were cleared.
-`;
-  } else if (blocked.length > 0) {
-    message += `⚠️ No paths were cleared. Review the blocked paths above and adjust your settings if needed.
-`;
-  }
-  await client.tui.appendPrompt({
-    body: {
-      type: "text",
-      text: message
-    }
-  });
-  if (cleared.length > 0) {
-    await client.tui.showToast({
-      body: {
-        type: "success",
-        message: `Cache cleared (${cleared.length} paths). Restart opencode to update.`
-      }
-    });
-  } else if (blocked.length > 0) {
-    await client.tui.showToast({
-      body: {
-        type: "error",
-        message: `Cache update blocked (${blocked.length} paths failed safety check)`
-      }
-    });
-  }
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `/manifold-update complete: cleared ${cleared.length}, skipped ${skipped.length}, blocked ${blocked.length}`
-    }
-  });
-}
-
 // src/index.ts
 var ManifoldPlugin = async (ctx) => {
   setPluginContext(ctx.client);
@@ -4706,27 +4485,12 @@ var ManifoldPlugin = async (ctx) => {
             }
           ];
         }
-      } else if (input.command === "manifold-models") {
-        await handleSubModelCommand(ctx.client, ctx.directory);
-        output.parts = [
-          {
-            type: "text",
-            text: "Sub-agent model configuration complete."
-          }
-        ];
-      } else if (input.command === "manifold-update") {
-        await handleUpdateCommand(ctx.client, ctx.directory);
-        output.parts = [
-          {
-            type: "text",
-            text: "Plugin cache update complete."
-          }
-        ];
       }
     }
   };
 };
 var server = ManifoldPlugin;
 export {
+  tui,
   server
 };