opencode-manifold 0.4.12 → 0.4.14

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);
@@ -2767,267 +2432,847 @@ function writeFlowMapping(state, level, object) {
     pairBuffer += state.dump;
     _result += pairBuffer;
   }
-  state.tag = _tag;
-  state.dump = "{" + _result + "}";
+  state.tag = _tag;
+  state.dump = "{" + _result + "}";
+}
+function writeBlockMapping(state, level, object, compact) {
+  var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
+  if (state.sortKeys === true) {
+    objectKeyList.sort();
+  } else if (typeof state.sortKeys === "function") {
+    objectKeyList.sort(state.sortKeys);
+  } else if (state.sortKeys) {
+    throw new exception("sortKeys must be a boolean or a function");
+  }
+  for (index = 0, length = objectKeyList.length;index < length; index += 1) {
+    pairBuffer = "";
+    if (!compact || _result !== "") {
+      pairBuffer += generateNextLine(state, level);
+    }
+    objectKey = objectKeyList[index];
+    objectValue = object[objectKey];
+    if (state.replacer) {
+      objectValue = state.replacer.call(object, objectKey, objectValue);
+    }
+    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
+      continue;
+    }
+    explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+    if (explicitPair) {
+      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+        pairBuffer += "?";
+      } else {
+        pairBuffer += "? ";
+      }
+    }
+    pairBuffer += state.dump;
+    if (explicitPair) {
+      pairBuffer += generateNextLine(state, level);
+    }
+    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);
+    }
+  });
+};
+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 { rm } = await import("fs/promises");
+  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 globalConfigDir = join(homedir(), ".config", "opencode", "manifold");
+  const configuredPaths = settings.updateCachePaths || [];
+  const pathsToClear = [...new Set([...configuredPaths, globalConfigDir])];
+  const resolvedPaths = pathsToClear.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 Plugin & Template Cache",
+          value: "confirm",
+          description: `Will clear ${resolvedPaths.length} path(s) including global templates`,
+          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 cleared = [];
+        const blocked = [];
+        for (const pathStr of resolvedPaths) {
+          try {
+            if (existsSync(pathStr)) {
+              await rm(pathStr, { recursive: true, force: true });
+              cleared.push(pathStr);
+            }
+          } catch (error) {
+            blocked.push({ path: pathStr, reason: `${error}` });
+          }
+        }
+        api.ui.toast({
+          variant: cleared.length > 0 ? "success" : "error",
+          message: cleared.length > 0 ? `Cache cleared. Restart opencode to update.` : `No paths cleared or 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";
+  }
 }
-function writeBlockMapping(state, level, object, compact) {
-  var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
-  if (state.sortKeys === true) {
-    objectKeyList.sort();
-  } else if (typeof state.sortKeys === "function") {
-    objectKeyList.sort(state.sortKeys);
-  } else if (state.sortKeys) {
-    throw new exception("sortKeys must be a boolean or a function");
+async function dirHasContent(dirPath) {
+  if (!existsSync2(dirPath))
+    return false;
+  try {
+    const entries = await readdir2(dirPath);
+    return entries.length > 0;
+  } catch {
+    return false;
   }
-  for (index = 0, length = objectKeyList.length;index < length; index += 1) {
-    pairBuffer = "";
-    if (!compact || _result !== "") {
-      pairBuffer += generateNextLine(state, level);
-    }
-    objectKey = objectKeyList[index];
-    objectValue = object[objectKey];
-    if (state.replacer) {
-      objectValue = state.replacer.call(object, objectKey, objectValue);
-    }
-    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
-      continue;
-    }
-    explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
-    if (explicitPair) {
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-        pairBuffer += "?";
-      } else {
-        pairBuffer += "? ";
+}
+async function copyMissingFiles(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 copyMissingFiles(srcPath, destPath);
+      if (subCopied.length > 0) {
+        copied.push(entry.name);
       }
+    } else if (!existsSync2(destPath)) {
+      await writeFile2(destPath, await readFile2(srcPath));
+      copied.push(entry.name);
     }
-    pairBuffer += state.dump;
-    if (explicitPair) {
-      pairBuffer += generateNextLine(state, level);
-    }
-    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
-      continue;
-    }
-    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-      pairBuffer += ":";
+  }
+  return copied;
+}
+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 {
-      pairBuffer += ": ";
+      await writeFile2(destPath, await readFile2(srcPath));
+      copied.push(entry.name);
     }
-    pairBuffer += state.dump;
-    _result += pairBuffer;
   }
-  state.tag = _tag;
-  state.dump = _result || "{}";
+  return copied;
 }
-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;
+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;
   }
-  return false;
+  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"
+    }
+  });
 }
-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 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;
   }
-  var type2 = _toString.call(state.dump);
-  var inblock = block;
-  var tagStr;
-  if (block) {
-    block = state.flowLevel < 0 || state.flowLevel > level;
+  const agentsCopied = await copyMissingFiles(join2(globalTemplatesDir, "agents"), join2(directory, ".opencode", "agents"));
+  if (agentsCopied.length > 0) {
+    initialized.push(`agents (${agentsCopied.join(", ")})`);
   }
-  var objectOrArray = type2 === "[object Object]" || type2 === "[object Array]", duplicateIndex, duplicate;
-  if (objectOrArray) {
-    duplicateIndex = state.duplicates.indexOf(object);
-    duplicate = duplicateIndex !== -1;
+  const skillsCopied = await copyMissingFiles(join2(globalTemplatesDir, "skills"), join2(directory, ".opencode", "skills"));
+  if (skillsCopied.length > 0) {
+    initialized.push(`skills (${skillsCopied.join(", ")})`);
   }
-  if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
-    compact = false;
+  const manifoldCopied = await copyMissingFiles(join2(globalTemplatesDir, "manifold"), join2(directory, "Manifold"));
+  if (manifoldCopied.length > 0) {
+    initialized.push(`Manifold/ (${manifoldCopied.join(", ")})`);
   }
-  if (duplicate && state.usedDuplicates[duplicateIndex]) {
-    state.dump = "*ref_" + duplicateIndex;
-  } else {
-    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
-      state.usedDuplicates[duplicateIndex] = true;
+  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 +3382,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 +3395,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 +3423,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 +3440,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 +3461,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 +3562,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 +3580,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 +3593,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 +4310,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 +4327,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 +4344,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 +4479,6 @@ var ManifoldPlugin = async (ctx) => {
 };
 var server = ManifoldPlugin;
 export {
+  tui,
   server
 };