opencode-manifold 0.4.12 → 0.4.13

package/dist/index.js

@@ -1,346 +1,11 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/init.ts
-import { readFile, writeFile, mkdir, readdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-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";
-  }
-}
-async function dirHasContent(dirPath) {
-  if (!existsSync(dirPath))
-    return false;
-  try {
-    const entries = await readdir(dirPath);
-    return entries.length > 0;
-  } catch {
-    return false;
-  }
-}
-async function copyMissingFiles(src, dest) {
-  if (!existsSync(src))
-    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;
-}
-async function ensureGlobalTemplates(ctx) {
-  await ctx.client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: "Checking global templates..."
-    }
-  });
-  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"
-    }
-  });
-}
-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(", ")})`);
-  }
-  const skillsCopied = await copyMissingFiles(join(globalTemplatesDir, "skills"), join(directory, ".opencode", "skills"));
-  if (skillsCopied.length > 0) {
-    initialized.push(`skills (${skillsCopied.join(", ")})`);
-  }
-  const manifoldCopied = await copyMissingFiles(join(globalTemplatesDir, "manifold"), join(directory, "Manifold"));
-  if (manifoldCopied.length > 0) {
-    initialized.push(`Manifold/ (${manifoldCopied.join(", ")})`);
-  }
-  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;
-}
-
-// 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));
-  }
-  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 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;
-          }
-        }
-      }
-    }
-  }
-  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 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";
+// src/tui.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+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 */
@@ -2804,230 +2469,822 @@ function writeBlockMapping(state, level, object, compact) {
     if (explicitPair) {
       pairBuffer += generateNextLine(state, level);
     }
-    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
-      continue;
+    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
+      continue;
+    }
+    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+      pairBuffer += ":";
+    } else {
+      pairBuffer += ": ";
+    }
+    pairBuffer += state.dump;
+    _result += pairBuffer;
+  }
+  state.tag = _tag;
+  state.dump = _result || "{}";
+}
+function detectType(state, object, explicit) {
+  var _result, typeList, index, length, type2, style;
+  typeList = explicit ? state.explicitTypes : state.implicitTypes;
+  for (index = 0, length = typeList.length;index < length; index += 1) {
+    type2 = typeList[index];
+    if ((type2.instanceOf || type2.predicate) && (!type2.instanceOf || typeof object === "object" && object instanceof type2.instanceOf) && (!type2.predicate || type2.predicate(object))) {
+      if (explicit) {
+        if (type2.multi && type2.representName) {
+          state.tag = type2.representName(object);
+        } else {
+          state.tag = type2.tag;
+        }
+      } else {
+        state.tag = "?";
+      }
+      if (type2.represent) {
+        style = state.styleMap[type2.tag] || type2.defaultStyle;
+        if (_toString.call(type2.represent) === "[object Function]") {
+          _result = type2.represent(object, style);
+        } else if (_hasOwnProperty.call(type2.represent, style)) {
+          _result = type2.represent[style](object, style);
+        } else {
+          throw new exception("!<" + type2.tag + '> tag resolver accepts not "' + style + '" style');
+        }
+        state.dump = _result;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function writeNode(state, level, object, block, compact, iskey, isblockseq) {
+  state.tag = null;
+  state.dump = object;
+  if (!detectType(state, object, false)) {
+    detectType(state, object, true);
+  }
+  var type2 = _toString.call(state.dump);
+  var inblock = block;
+  var tagStr;
+  if (block) {
+    block = state.flowLevel < 0 || state.flowLevel > level;
+  }
+  var objectOrArray = type2 === "[object Object]" || type2 === "[object Array]", duplicateIndex, duplicate;
+  if (objectOrArray) {
+    duplicateIndex = state.duplicates.indexOf(object);
+    duplicate = duplicateIndex !== -1;
+  }
+  if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
+    compact = false;
+  }
+  if (duplicate && state.usedDuplicates[duplicateIndex]) {
+    state.dump = "*ref_" + duplicateIndex;
+  } else {
+    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
+      state.usedDuplicates[duplicateIndex] = true;
+    }
+    if (type2 === "[object Object]") {
+      if (block && Object.keys(state.dump).length !== 0) {
+        writeBlockMapping(state, level, state.dump, compact);
+        if (duplicate) {
+          state.dump = "&ref_" + duplicateIndex + state.dump;
+        }
+      } else {
+        writeFlowMapping(state, level, state.dump);
+        if (duplicate) {
+          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+        }
+      }
+    } else if (type2 === "[object Array]") {
+      if (block && state.dump.length !== 0) {
+        if (state.noArrayIndent && !isblockseq && level > 0) {
+          writeBlockSequence(state, level - 1, state.dump, compact);
+        } else {
+          writeBlockSequence(state, level, state.dump, compact);
+        }
+        if (duplicate) {
+          state.dump = "&ref_" + duplicateIndex + state.dump;
+        }
+      } else {
+        writeFlowSequence(state, level, state.dump);
+        if (duplicate) {
+          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+        }
+      }
+    } else if (type2 === "[object String]") {
+      if (state.tag !== "?") {
+        writeScalar(state, state.dump, level, iskey, inblock);
+      }
+    } else if (type2 === "[object Undefined]") {
+      return false;
+    } else {
+      if (state.skipInvalid)
+        return false;
+      throw new exception("unacceptable kind of an object to dump " + type2);
+    }
+    if (state.tag !== null && state.tag !== "?") {
+      tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
+      if (state.tag[0] === "!") {
+        tagStr = "!" + tagStr;
+      } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") {
+        tagStr = "!!" + tagStr.slice(18);
+      } else {
+        tagStr = "!<" + tagStr + ">";
+      }
+      state.dump = tagStr + " " + state.dump;
+    }
+  }
+  return true;
+}
+function getDuplicateReferences(object, state) {
+  var objects = [], duplicatesIndexes = [], index, length;
+  inspectNode(object, objects, duplicatesIndexes);
+  for (index = 0, length = duplicatesIndexes.length;index < length; index += 1) {
+    state.duplicates.push(objects[duplicatesIndexes[index]]);
+  }
+  state.usedDuplicates = new Array(length);
+}
+function inspectNode(object, objects, duplicatesIndexes) {
+  var objectKeyList, index, length;
+  if (object !== null && typeof object === "object") {
+    index = objects.indexOf(object);
+    if (index !== -1) {
+      if (duplicatesIndexes.indexOf(index) === -1) {
+        duplicatesIndexes.push(index);
+      }
+    } else {
+      objects.push(object);
+      if (Array.isArray(object)) {
+        for (index = 0, length = object.length;index < length; index += 1) {
+          inspectNode(object[index], objects, duplicatesIndexes);
+        }
+      } else {
+        objectKeyList = Object.keys(object);
+        for (index = 0, length = objectKeyList.length;index < length; index += 1) {
+          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+        }
+      }
+    }
+  }
+}
+function dump$1(input, options) {
+  options = options || {};
+  var state = new State(options);
+  if (!state.noRefs)
+    getDuplicateReferences(input, state);
+  var value = input;
+  if (state.replacer) {
+    value = state.replacer.call({ "": value }, "", value);
+  }
+  if (writeNode(state, 0, value, true, true))
+    return state.dump + `
+`;
+  return "";
+}
+var dump_1 = dump$1;
+var dumper = {
+  dump: dump_1
+};
+function renamed(from, to) {
+  return function() {
+    throw new Error("Function yaml." + from + " is removed in js-yaml 4. " + "Use yaml." + to + " instead, which is now safe by default.");
+  };
+}
+var Type = type;
+var Schema = schema;
+var FAILSAFE_SCHEMA = failsafe;
+var JSON_SCHEMA = json;
+var CORE_SCHEMA = core;
+var DEFAULT_SCHEMA = _default;
+var load = loader.load;
+var loadAll = loader.loadAll;
+var dump = dumper.dump;
+var YAMLException = exception;
+var types = {
+  binary,
+  float,
+  map,
+  null: _null,
+  pairs,
+  set,
+  timestamp,
+  bool,
+  int,
+  merge,
+  omap,
+  seq,
+  str
+};
+var safeLoad = renamed("safeLoad", "load");
+var safeLoadAll = renamed("safeLoadAll", "loadAll");
+var safeDump = renamed("safeDump", "dump");
+var jsYaml = {
+  Type,
+  Schema,
+  FAILSAFE_SCHEMA,
+  JSON_SCHEMA,
+  CORE_SCHEMA,
+  DEFAULT_SCHEMA,
+  load,
+  loadAll,
+  dump,
+  YAMLException,
+  types,
+  safeLoad,
+  safeLoadAll,
+  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);
     }
-    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-      pairBuffer += ":";
-    } else {
-      pairBuffer += ": ";
+  });
+};
+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
+        });
+      }
     }
-    pairBuffer += state.dump;
-    _result += pairBuffer;
   }
-  state.tag = _tag;
-  state.dump = _result || "{}";
+  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();
+          }
+        });
+      }
+    });
+  });
 }
-function detectType(state, object, explicit) {
-  var _result, typeList, index, length, type2, style;
-  typeList = explicit ? state.explicitTypes : state.implicitTypes;
-  for (index = 0, length = typeList.length;index < length; index += 1) {
-    type2 = typeList[index];
-    if ((type2.instanceOf || type2.predicate) && (!type2.instanceOf || typeof object === "object" && object instanceof type2.instanceOf) && (!type2.predicate || type2.predicate(object))) {
-      if (explicit) {
-        if (type2.multi && type2.representName) {
-          state.tag = type2.representName(object);
-        } else {
-          state.tag = type2.tag;
+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"
         }
-      } else {
-        state.tag = "?";
+      ],
+      onSelect: () => {
+        api.ui.toast({
+          variant: "info",
+          message: "Add updateCachePaths to Manifold/settings.json"
+        });
       }
-      if (type2.represent) {
-        style = state.styleMap[type2.tag] || type2.defaultStyle;
-        if (_toString.call(type2.represent) === "[object Function]") {
-          _result = type2.represent(object, style);
-        } else if (_hasOwnProperty.call(type2.represent, style)) {
-          _result = type2.represent[style](object, style);
-        } else {
-          throw new exception("!<" + type2.tag + '> tag resolver accepts not "' + style + '" style');
+    });
+    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"
         }
-        state.dump = _result;
+      ],
+      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();
       }
-      return true;
+    });
+  });
+}
+
+// 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 false;
+  return copied;
 }
-function writeNode(state, level, object, block, compact, iskey, isblockseq) {
-  state.tag = null;
-  state.dump = object;
-  if (!detectType(state, object, false)) {
-    detectType(state, object, true);
+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;
   }
-  var type2 = _toString.call(state.dump);
-  var inblock = block;
-  var tagStr;
-  if (block) {
-    block = state.flowLevel < 0 || state.flowLevel > level;
+  await copyFiles(bundledTemplatesDir, globalTemplatesDir);
+  const globalCommandsDir = join2(homedir2(), ".config", "opencode", "commands");
+  const bundledCommandsDir = join2(bundledTemplatesDir, "commands");
+  if (existsSync2(bundledCommandsDir)) {
+    await copyFiles(bundledCommandsDir, globalCommandsDir);
   }
-  var objectOrArray = type2 === "[object Object]" || type2 === "[object Array]", duplicateIndex, duplicate;
-  if (objectOrArray) {
-    duplicateIndex = state.duplicates.indexOf(object);
-    duplicate = duplicateIndex !== -1;
+  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;
   }
-  if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
-    compact = false;
+  const agentsCopied = await copyMissingFiles(join2(globalTemplatesDir, "agents"), join2(directory, ".opencode", "agents"));
+  if (agentsCopied.length > 0) {
+    initialized.push(`agents (${agentsCopied.join(", ")})`);
   }
-  if (duplicate && state.usedDuplicates[duplicateIndex]) {
-    state.dump = "*ref_" + duplicateIndex;
-  } else {
-    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
-      state.usedDuplicates[duplicateIndex] = true;
+  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"}`
     }
-    if (type2 === "[object Object]") {
-      if (block && Object.keys(state.dump).length !== 0) {
-        writeBlockMapping(state, level, state.dump, compact);
-        if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + state.dump;
-        }
-      } else {
-        writeFlowMapping(state, level, state.dump);
-        if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
-        }
+  });
+  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;
       }
-    } else if (type2 === "[object Array]") {
-      if (block && state.dump.length !== 0) {
-        if (state.noArrayIndent && !isblockseq && level > 0) {
-          writeBlockSequence(state, level - 1, state.dump, compact);
-        } else {
-          writeBlockSequence(state, level, state.dump, compact);
-        }
-        if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + state.dump;
-        }
-      } else {
-        writeFlowSequence(state, level, state.dump);
-        if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+      if (status.type === "retry") {
+        const waitTime = status.next - Date.now();
+        if (waitTime > 0) {
+          await new Promise((resolve) => setTimeout(resolve, Math.min(waitTime, 1000)));
         }
+        continue;
       }
-    } else if (type2 === "[object String]") {
-      if (state.tag !== "?") {
-        writeScalar(state, state.dump, level, iskey, inblock);
-      }
-    } else if (type2 === "[object Undefined]") {
-      return false;
-    } else {
-      if (state.skipInvalid)
-        return false;
-      throw new exception("unacceptable kind of an object to dump " + type2);
-    }
-    if (state.tag !== null && state.tag !== "?") {
-      tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
-      if (state.tag[0] === "!") {
-        tagStr = "!" + tagStr;
-      } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") {
-        tagStr = "!!" + tagStr.slice(18);
-      } else {
-        tagStr = "!<" + tagStr + ">";
-      }
-      state.dump = tagStr + " " + state.dump;
     }
+    await new Promise((resolve) => setTimeout(resolve, 500));
   }
-  return true;
+  return false;
 }
-function getDuplicateReferences(object, state) {
-  var objects = [], duplicatesIndexes = [], index, length;
-  inspectNode(object, objects, duplicatesIndexes);
-  for (index = 0, length = duplicatesIndexes.length;index < length; index += 1) {
-    state.duplicates.push(objects[duplicatesIndexes[index]]);
+async function getLastAssistantMessage(client, sessionId) {
+  const messagesResponse = await client.session.messages({
+    path: { id: sessionId }
+  });
+  const messages = messagesResponse.data;
+  if (!messages || !Array.isArray(messages)) {
+    return "";
   }
-  state.usedDuplicates = new Array(length);
+  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 "";
 }
-function inspectNode(object, objects, duplicatesIndexes) {
-  var objectKeyList, index, length;
-  if (object !== null && typeof object === "object") {
-    index = objects.indexOf(object);
-    if (index !== -1) {
-      if (duplicatesIndexes.indexOf(index) === -1) {
-        duplicatesIndexes.push(index);
+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}`
       }
-    } else {
-      objects.push(object);
-      if (Array.isArray(object)) {
-        for (index = 0, length = object.length;index < length; index += 1) {
-          inspectNode(object[index], objects, duplicatesIndexes);
-        }
-      } else {
-        objectKeyList = Object.keys(object);
-        for (index = 0, length = objectKeyList.length;index < length; index += 1) {
-          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+    });
+    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)
+    };
   }
 }
-function dump$1(input, options) {
-  options = options || {};
-  var state = new State(options);
-  if (!state.noRefs)
-    getDuplicateReferences(input, state);
-  var value = input;
-  if (state.replacer) {
-    value = state.replacer.call({ "": value }, "", value);
+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";
   }
-  if (writeNode(state, 0, value, true, true))
-    return state.dump + `
-`;
-  return "";
+  return "QUESTIONS";
 }
-var dump_1 = dump$1;
-var dumper = {
-  dump: dump_1
-};
-function renamed(from, to) {
-  return function() {
-    throw new Error("Function yaml." + from + " is removed in js-yaml 4. " + "Use yaml." + to + " instead, which is now safe by default.");
-  };
+
+// 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;
 }
-var Type = type;
-var Schema = schema;
-var FAILSAFE_SCHEMA = failsafe;
-var JSON_SCHEMA = json;
-var CORE_SCHEMA = core;
-var DEFAULT_SCHEMA = _default;
-var load = loader.load;
-var loadAll = loader.loadAll;
-var dump = dumper.dump;
-var YAMLException = exception;
-var types = {
-  binary,
-  float,
-  map,
-  null: _null,
-  pairs,
-  set,
-  timestamp,
-  bool,
-  int,
-  merge,
-  omap,
-  seq,
-  str
-};
-var safeLoad = renamed("safeLoad", "load");
-var safeLoadAll = renamed("safeLoadAll", "loadAll");
-var safeDump = renamed("safeDump", "dump");
-var jsYaml = {
-  Type,
-  Schema,
-  FAILSAFE_SCHEMA,
-  JSON_SCHEMA,
-  CORE_SCHEMA,
-  DEFAULT_SCHEMA,
-  load,
-  loadAll,
-  dump,
-  YAMLException,
-  types,
-  safeLoad,
-  safeLoadAll,
-  safeDump
-};
 
 // 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() {
@@ -4234,5 +4491,6 @@ var ManifoldPlugin = async (ctx) => {
 };
 var server = ManifoldPlugin;
 export {
+  tui,
   server
 };