opencode-manifold 0.4.17 → 0.4.19

package/dist/index.js

@@ -1,15 +1,12 @@
-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";
+import { createRequire } from "module";
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var require2 = createRequire2(import.meta.url);
+var require2 = createRequire(import.meta.url);
 var bundledTemplatesDir = join(__dirname2, "..", "src", "templates");
 var globalTemplatesDir = join(homedir(), ".config", "opencode", "manifold");
 async function getPluginVersion() {
@@ -4216,6 +4213,484 @@ ${testResult.result.output}`,
   }
 });
 
+// src/tools/set-subagent-model.ts
+import { readFile as readFile5, writeFile as writeFile5, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir2 } from "os";
+var MANIFOLD_AGENTS = ["clerk", "senior-dev", "junior-dev", "debug"];
+async function getManifoldAgents(directory) {
+  const agentsDir = join6(directory, ".opencode", "agents");
+  if (!existsSync6(agentsDir)) {
+    return [];
+  }
+  const files = await readdir3(agentsDir);
+  const agents = [];
+  for (const file of files) {
+    if (!file.endsWith(".md"))
+      continue;
+    const name = file.replace(".md", "");
+    if (MANIFOLD_AGENTS.includes(name)) {
+      agents.push(name);
+    }
+  }
+  return agents;
+}
+async function getAvailableModels(client) {
+  try {
+    const result = await client.config.providers();
+    const providers = result.data?.providers || [];
+    const models = [];
+    for (const provider of providers) {
+      if (provider.models) {
+        for (const [modelId, model] of Object.entries(provider.models)) {
+          models.push({
+            id: `${provider.id}/${modelId}`,
+            name: model.name || modelId,
+            providerID: provider.id
+          });
+        }
+      }
+    }
+    return models.sort((a, b) => a.name.localeCompare(b.name));
+  } catch (error) {
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "error",
+        message: `Error fetching models: ${error}`
+      }
+    });
+    return [];
+  }
+}
+async function readAgentFile(agentName, directory) {
+  const agentPath = join6(directory, ".opencode", "agents", `${agentName}.md`);
+  if (!existsSync6(agentPath)) {
+    const globalPath = join6(homedir2(), ".config", "opencode", "manifold", "agents", `${agentName}.md`);
+    if (existsSync6(globalPath)) {
+      const content2 = await readFile5(globalPath, "utf-8");
+      const { frontmatter: frontmatter2, body: body2 } = parseFrontmatter(content2);
+      return { content: content2, frontmatter: frontmatter2, body: body2 };
+    }
+    throw new Error(`Agent file not found for ${agentName}`);
+  }
+  const content = await readFile5(agentPath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+  return { content, frontmatter, body };
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const frontmatterYaml = match[1];
+  const body = match[2];
+  const frontmatter = jsYaml.load(frontmatterYaml) || {};
+  return { frontmatter, body };
+}
+function buildAgentFile(frontmatter, body) {
+  const yamlContent = jsYaml.dump(frontmatter, {
+    lineWidth: -1,
+    noCompatMode: true
+  });
+  return `---
+${yamlContent}---
+${body}`;
+}
+async function updateAgentModel(client, agentName, modelId, directory) {
+  const { frontmatter, body } = await readAgentFile(agentName, directory);
+  frontmatter.model = modelId;
+  const newContent = buildAgentFile(frontmatter, body);
+  const agentPath = join6(directory, ".opencode", "agents", `${agentName}.md`);
+  await writeFile5(agentPath, newContent);
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Updated ${agentName} model to ${modelId}`
+    }
+  });
+}
+async function handleSubModelCommand(client, directory) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: "Starting /sub-model command"
+    }
+  });
+  const agents = await getManifoldAgents(directory);
+  if (agents.length === 0) {
+    await client.tui.showToast({
+      body: {
+        type: "error",
+        message: "No Manifold agents found. Run /manifold-init first."
+      }
+    });
+    return;
+  }
+  const models = await getAvailableModels(client);
+  if (models.length === 0) {
+    await client.tui.showToast({
+      body: {
+        type: "error",
+        message: "No models available. Configure providers first."
+      }
+    });
+    return;
+  }
+  const agentList = agents.map((a) => `${a} (sub-agent)`).join(`
+`);
+  await client.tui.appendPrompt({
+    body: {
+      type: "text",
+      text: `\uD83D\uDCCB Select a Manifold sub-agent to configure:
+
+${agentList}`
+    }
+  });
+  await client.tui.publish({
+    body: {
+      type: "tui.prompt_append",
+      data: {
+        type: "text",
+        text: `
+
+Type the agent name (clerk, senior-dev, junior-dev, or debug): `
+      }
+    }
+  });
+  const agentResponse = await client.tui.control.next();
+  const selectedAgent = agentResponse.data?.input?.trim().toLowerCase();
+  if (!selectedAgent || !MANIFOLD_AGENTS.includes(selectedAgent)) {
+    await client.tui.showToast({
+      body: {
+        type: "error",
+        message: `Invalid agent selection. Must be one of: ${MANIFOLD_AGENTS.join(", ")}`
+      }
+    });
+    return;
+  }
+  if (!agents.includes(selectedAgent)) {
+    await client.tui.showToast({
+      body: {
+        type: "error",
+        message: `Agent ${selectedAgent} not found in .opencode/agents/`
+      }
+    });
+    return;
+  }
+  const currentModel = await readAgentFile(selectedAgent, directory).then((f) => f.frontmatter.model || "not set");
+  const modelList = models.map((m, i2) => `${i2 + 1}. ${m.name} (${m.id})`).join(`
+`);
+  await client.tui.appendPrompt({
+    body: {
+      type: "text",
+      text: `
+\uD83D\uDCE6 Available models for ${selectedAgent} (current: ${currentModel}):
+
+${modelList}`
+    }
+  });
+  await client.tui.publish({
+    body: {
+      type: "tui.prompt_append",
+      data: {
+        type: "text",
+        text: `
+
+Type the model number or full model ID (e.g., anthropic/claude-sonnet-4-20250514): `
+      }
+    }
+  });
+  const modelResponse = await client.tui.control.next();
+  const selectedModelInput = modelResponse.data?.input?.trim();
+  if (!selectedModelInput) {
+    await client.tui.showToast({
+      body: {
+        type: "error",
+        message: "No model selected"
+      }
+    });
+    return;
+  }
+  let selectedModelId;
+  const modelIndex = parseInt(selectedModelInput, 10) - 1;
+  if (!isNaN(modelIndex) && modelIndex >= 0 && modelIndex < models.length) {
+    selectedModelId = models[modelIndex].id;
+  } else {
+    const found = models.find((m) => m.id.toLowerCase() === selectedModelInput.toLowerCase());
+    if (found) {
+      selectedModelId = found.id;
+    }
+  }
+  if (!selectedModelId) {
+    await client.tui.showToast({
+      body: {
+        type: "error",
+        message: `Invalid model selection: ${selectedModelInput}`
+      }
+    });
+    return;
+  }
+  await updateAgentModel(client, selectedAgent, selectedModelId, directory);
+  await client.tui.showToast({
+    body: {
+      type: "success",
+      message: `✅ Set ${selectedAgent} to ${selectedModelId}`
+    }
+  });
+  await client.tui.appendPrompt({
+    body: {
+      type: "text",
+      text: `
+✅ Model updated for ${selectedAgent}: ${selectedModelId}
+`
+    }
+  });
+}
+
+// src/tools/clear-cache.ts
+import { rm } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { join as join7, isAbsolute } from "path";
+import { homedir as homedir3 } from "os";
+var PROTECTED_PATHS = [
+  "/",
+  "/System",
+  "/Applications",
+  "/Users",
+  "/etc",
+  "/bin",
+  "/sbin",
+  "/usr"
+];
+function resolvePath(pathStr) {
+  const expanded = pathStr.startsWith("~") ? join7(homedir3(), pathStr.slice(1)) : pathStr;
+  return isAbsolute(expanded) ? expanded : join7(process.cwd(), expanded);
+}
+function isPathSafe(pathStr) {
+  const normalized = pathStr.toLowerCase();
+  if (normalized.includes("*")) {
+    return { safe: false, reason: "Wildcards are not allowed for safety" };
+  }
+  for (const protectedPath of PROTECTED_PATHS) {
+    if (normalized === protectedPath.toLowerCase() || normalized.startsWith(protectedPath.toLowerCase() + "/") || normalized.startsWith(protectedPath.toLowerCase() + "\\")) {
+      return { safe: false, reason: `Cannot delete protected system path: ${protectedPath}` };
+    }
+  }
+  if (normalized === homedir3().toLowerCase() || normalized.startsWith(homedir3().toLowerCase() + "/") && !normalized.includes("cache") && !normalized.includes("node_modules")) {
+    const parts = normalized.replace(homedir3().toLowerCase(), "").split(/[\/\\]/).filter(Boolean);
+    if (parts.length === 1) {
+      return { safe: false, reason: "Cannot delete directories directly in home folder" };
+    }
+  }
+  return { safe: true };
+}
+async function isProjectDirectory(pathStr) {
+  try {
+    const hasGit = existsSync7(join7(pathStr, ".git"));
+    const hasOpencodeConfig = existsSync7(join7(pathStr, "opencode.json"));
+    const hasPackageJson = existsSync7(join7(pathStr, "package.json"));
+    if (hasGit && (hasOpencodeConfig || hasPackageJson)) {
+      return true;
+    }
+    const entries = await Promise.all([
+      existsSync7(join7(pathStr, ".git")) ? "git" : null,
+      existsSync7(join7(pathStr, "opencode.json")) ? "opencode" : null
+    ].filter(Boolean));
+    return entries.length >= 2;
+  } catch {
+    return false;
+  }
+}
+async function clearCachePaths(paths) {
+  const cleared = [];
+  const skipped = [];
+  const blocked = [];
+  for (const pathStr of paths) {
+    const resolved = resolvePath(pathStr);
+    const safetyCheck = isPathSafe(resolved);
+    if (!safetyCheck.safe) {
+      blocked.push({ path: resolved, reason: safetyCheck.reason || "Failed safety check" });
+      continue;
+    }
+    if (!existsSync7(resolved)) {
+      skipped.push(resolved);
+      continue;
+    }
+    const isProject = await isProjectDirectory(resolved);
+    if (isProject) {
+      blocked.push({ path: resolved, reason: "Appears to be a project directory (contains .git + config files)" });
+      continue;
+    }
+    try {
+      await rm(resolved, { recursive: true, force: true });
+      cleared.push(resolved);
+    } catch (error) {
+      blocked.push({ path: resolved, reason: `Failed to delete: ${error}` });
+    }
+  }
+  return { cleared, skipped, blocked };
+}
+async function handleUpdateCommand(client, directory) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: "Starting /manifold-update command"
+    }
+  });
+  const settings = await readSettings(directory);
+  const configuredPaths = settings.updateCachePaths || [];
+  if (configuredPaths.length === 0) {
+    const examplePaths = [
+      "~/.cache/opencode/packages/opencode-manifold@latest",
+      "~/node_modules/opencode-manifold"
+    ];
+    await client.tui.appendPrompt({
+      body: {
+        type: "text",
+        text: `\uD83D\uDD04 **Manifold Plugin Update**
+
+No cache paths configured in \`Manifold/settings.json\`.
+
+To enable this feature, add cache paths to your settings:
+
+\`\`\`json
+{
+  "updateCachePaths": [
+    "~/.cache/opencode/packages/opencode-manifold@latest",
+    "~/node_modules/opencode-manifold"
+  ]
+}
+\`\`\`
+
+**Safety features:**
+• Wildcards are blocked
+• System directories are protected
+• Project directories (with .git + config) are protected
+
+**macOS users:** The paths above are typical cache locations.
+**Linux/Windows users:** Add your opencode cache paths manually.
+`
+      }
+    });
+    await client.tui.showToast({
+      body: {
+        type: "info",
+        message: "Configure updateCachePaths in Manifold/settings.json"
+      }
+    });
+    return;
+  }
+  const resolvedPaths = configuredPaths.map(resolvePath);
+  await client.tui.appendPrompt({
+    body: {
+      type: "text",
+      text: `\uD83D\uDD04 **Manifold Plugin Update**
+
+The following paths will be cleared:
+
+${resolvedPaths.map((p) => `• ${p}`).join(`
+`)}
+
+⚠️ **This action is irreversible.** These paths are read from \`Manifold/settings.json\`.
+`
+    }
+  });
+  await client.tui.publish({
+    body: {
+      type: "tui.prompt_append",
+      data: {
+        type: "text",
+        text: `
+
+Type 'yes' to confirm and clear cache: `
+      }
+    }
+  });
+  const response = await client.tui.control.next();
+  const answer = response.data?.input?.trim().toLowerCase();
+  if (answer !== "yes" && answer !== "y") {
+    await client.tui.appendPrompt({
+      body: {
+        type: "text",
+        text: `
+❌ Cancelled. No cache cleared.
+`
+      }
+    });
+    return;
+  }
+  const { cleared, skipped, blocked } = await clearCachePaths(configuredPaths);
+  let message = `
+`;
+  if (cleared.length > 0) {
+    message += `✅ **Cleared:**
+${cleared.map((p) => `• ${p}`).join(`
+`)}
+
+`;
+  }
+  if (skipped.length > 0) {
+    message += `⏭️ **Already clean / skipped:**
+${skipped.map((p) => `• ${p}`).join(`
+`)}
+
+`;
+  }
+  if (blocked.length > 0) {
+    message += `\uD83D\uDEAB **Blocked (safety check):**
+`;
+    for (const item of blocked) {
+      message += `• ${item.path}
+  Reason: ${item.reason}
+`;
+    }
+    message += `
+`;
+  }
+  if (cleared.length > 0) {
+    message += `**Next step:** Restart opencode to pull the latest plugin version.
+
+Your project files (.opencode/, Manifold/) are untouched — only the configured cache paths were cleared.
+`;
+  } else if (blocked.length > 0) {
+    message += `⚠️ No paths were cleared. Review the blocked paths above and adjust your settings if needed.
+`;
+  }
+  await client.tui.appendPrompt({
+    body: {
+      type: "text",
+      text: message
+    }
+  });
+  if (cleared.length > 0) {
+    await client.tui.showToast({
+      body: {
+        type: "success",
+        message: `Cache cleared (${cleared.length} paths). Restart opencode to update.`
+      }
+    });
+  } else if (blocked.length > 0) {
+    await client.tui.showToast({
+      body: {
+        type: "error",
+        message: `Cache update blocked (${blocked.length} paths failed safety check)`
+      }
+    });
+  }
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `/manifold-update complete: cleared ${cleared.length}, skipped ${skipped.length}, blocked ${blocked.length}`
+    }
+  });
+}
+
 // src/index.ts
 var ManifoldPlugin = async (ctx) => {
   setPluginContext(ctx.client);
@@ -4249,6 +4724,12 @@ var ManifoldPlugin = async (ctx) => {
             }
           ];
         }
+      } else if (input.command === "manifold-models") {
+        await handleSubModelCommand(ctx.client, ctx.directory);
+        output.parts = [{ type: "text", text: "Manifold sub-agent configuration started." }];
+      } else if (input.command === "manifold-update") {
+        await handleUpdateCommand(ctx.client, ctx.directory);
+        output.parts = [{ type: "text", text: "Manifold update process started." }];
       }
     }
   };

package/dist/tui.js

@@ -1,12 +1,3 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// 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 */
 function isNothing(subject) {
@@ -2693,65 +2684,6 @@ var jsYaml = {
 };
 
 // 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(() => [
     {
@@ -2770,8 +2702,7 @@ var tui = async (api) => {
       category: "Manifold",
       slash: {
         name: "manifold-models"
-      },
-      onSelect: () => handleManifoldModels(api)
+      }
     },
     {
       title: "Manifold Update",
@@ -2780,150 +2711,10 @@ var tui = async (api) => {
       category: "Manifold",
       slash: {
         name: "manifold-update"
-      },
-      onSelect: () => handleManifoldUpdate(api)
+      }
     }
   ]);
 };
-function handleManifoldModels(api) {
-  const directory = api.state.path.directory;
-  getManifoldAgents(directory).then((agents) => {
-    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.replace(() => api.ui.DialogSelect({
-      title: "Select Manifold Sub-Agent",
-      options: agentOptions,
-      onSelect: (option) => {
-        const selectedAgent = option.value;
-        readAgentFile(selectedAgent, directory).then(({ frontmatter }) => {
-          const currentModel = frontmatter.model || "not set";
-          const modelOptions = models.map((model) => ({
-            title: `${model.name}`,
-            value: model.id,
-            description: model.id,
-            footer: model.id === currentModel ? "✓ Current" : undefined
-          }));
-          api.ui.dialog.replace(() => api.ui.DialogSelect({
-            title: `Select Model for ${selectedAgent}`,
-            options: modelOptions,
-            current: currentModel !== "not set" ? currentModel : undefined,
-            onSelect: (modelOption) => {
-              const selectedModelId = modelOption.value;
-              updateAgentModel(selectedAgent, selectedModelId, directory).then(() => {
-                api.ui.toast({
-                  variant: "success",
-                  message: `Set ${selectedAgent} to ${selectedModelId}`
-                });
-                api.ui.dialog.clear();
-              });
-            }
-          }));
-        }).catch(() => {
-          api.ui.toast({
-            variant: "error",
-            message: `Error reading agent file for ${selectedAgent}`
-          });
-        });
-      }
-    }));
-  });
-}
-function handleManifoldUpdate(api) {
-  const directory = api.state.path.directory;
-  const settingsPath = join(directory, "Manifold", "settings.json");
-  const proceed = (settings) => {
-    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.replace(() => api.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: (option) => {
-        if (option.value === "cancel") {
-          api.ui.dialog.clear();
-          return;
-        }
-        import("fs/promises").then(({ rm }) => {
-          const cleared = [];
-          const promises = resolvedPaths.map((pathStr) => {
-            if (existsSync(pathStr)) {
-              return rm(pathStr, { recursive: true, force: true }).then(() => {
-                cleared.push(pathStr);
-              }).catch(() => {});
-            }
-            return Promise.resolve();
-          });
-          Promise.all(promises).then(() => {
-            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`
-            });
-            api.ui.dialog.clear();
-          });
-        });
-      }
-    }));
-  };
-  if (existsSync(settingsPath)) {
-    readFile(settingsPath, "utf-8").then((content) => {
-      try {
-        proceed(JSON.parse(content));
-      } catch {
-        proceed({});
-      }
-    }).catch(() => proceed({}));
-  } else {
-    proceed({});
-  }
-}
 export {
   tui
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-manifold",
-  "version": "0.4.17",
+  "version": "0.4.19",
   "description": "Multi-agent development system for opencode with persistent knowledge",
   "main": "dist/index.js",
   "type": "module",