opencode-swarm 4.3.1 → 4.4.0

package/dist/cli/index.js

@@ -96,6 +96,66 @@ Next steps:`);
   console.log("   what expertise is needed and requests it dynamically.");
   return 0;
 }
+async function uninstall() {
+  try {
+    console.log(`\uD83D\uDC1D Uninstalling OpenCode Swarm...
+`);
+    const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
+    if (!opencodeConfig) {
+      if (fs.existsSync(OPENCODE_CONFIG_PATH)) {
+        console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
+        return 1;
+      } else {
+        console.log(`\u26A0 No opencode config found at: ${OPENCODE_CONFIG_PATH}`);
+        console.log("Nothing to uninstall.");
+        return 0;
+      }
+    }
+    if (!opencodeConfig.plugin || opencodeConfig.plugin.length === 0) {
+      console.log("\u26A0 opencode-swarm is not installed (no plugins configured).");
+      return 0;
+    }
+    const pluginName = "opencode-swarm";
+    const filteredPlugins = opencodeConfig.plugin.filter((p) => p !== pluginName && !p.startsWith(`${pluginName}@`));
+    if (filteredPlugins.length === opencodeConfig.plugin.length) {
+      console.log("\u26A0 opencode-swarm is not installed.");
+      return 0;
+    }
+    opencodeConfig.plugin = filteredPlugins;
+    if (opencodeConfig.agent) {
+      delete opencodeConfig.agent.explore;
+      delete opencodeConfig.agent.general;
+      if (Object.keys(opencodeConfig.agent).length === 0) {
+        delete opencodeConfig.agent;
+      }
+    }
+    saveJson(OPENCODE_CONFIG_PATH, opencodeConfig);
+    console.log("\u2713 Removed opencode-swarm from OpenCode plugins");
+    console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
+    if (process.argv.includes("--clean")) {
+      let cleaned = false;
+      if (fs.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs.unlinkSync(PLUGIN_CONFIG_PATH);
+        console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
+        cleaned = true;
+      }
+      if (fs.existsSync(PROMPTS_DIR)) {
+        fs.rmSync(PROMPTS_DIR, { recursive: true });
+        console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
+        cleaned = true;
+      }
+      if (!cleaned) {
+        console.log("\u2713 No config files to clean up");
+      }
+    }
+    console.log(`
+\u2705 Uninstall complete!`);
+    return 0;
+  } catch (error) {
+    console.log("\u2717 Uninstall failed: " + (error instanceof Error ? error.message : String(error)));
+    return 1;
+  }
+}
 function printHelp() {
   console.log(`
 opencode-swarm - Architect-centric agentic swarm plugin for OpenCode
@@ -104,8 +164,10 @@ Usage: bunx opencode-swarm [command] [OPTIONS]
 
 Commands:
   install     Install and configure the plugin (default)
+  uninstall   Remove the plugin from OpenCode config
 
 Options:
+  --clean     Also remove config files and custom prompts (with uninstall)
   -h, --help  Show this help message
 
 Configuration:
@@ -122,6 +184,8 @@ Custom Prompts:
 
 Examples:
   bunx opencode-swarm install
+  bunx opencode-swarm uninstall
+  bunx opencode-swarm uninstall --clean
   bunx opencode-swarm --help
 `);
 }
@@ -135,6 +199,9 @@ async function main() {
   if (command === "install") {
     const exitCode = await install();
     process.exit(exitCode);
+  } else if (command === "uninstall") {
+    const exitCode = await uninstall();
+    process.exit(exitCode);
   } else {
     console.error(`Unknown command: ${command}`);
     console.error("Run with --help for usage information");

package/dist/commands/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles the /swarm config command.
+ * Loads and displays the current resolved plugin configuration.
+ */
+export declare function handleConfigCommand(directory: string, _args: string[]): Promise<string>;

package/dist/commands/history.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles the /swarm history command.
+ * Reads plan.md and displays a summary of all phases and their status.
+ */
+export declare function handleHistoryCommand(directory: string, _args: string[]): Promise<string>;

package/dist/commands/index.d.ts

@@ -1,5 +1,7 @@
 import type { AgentDefinition } from '../agents';
 export { handleAgentsCommand } from './agents';
+export { handleConfigCommand } from './config';
+export { handleHistoryCommand } from './history';
 export { handlePlanCommand } from './plan';
 export { handleStatusCommand } from './status';
 /**

package/dist/config/loader.d.ts

@@ -1,4 +1,6 @@
 import { type PluginConfig } from './schema';
+export declare const MAX_CONFIG_FILE_BYTES = 102400;
+export declare const MAX_MERGE_DEPTH = 10;
 /**
  * Deep merge two objects, with override values taking precedence.
  */

package/dist/hooks/index.d.ts

@@ -5,4 +5,4 @@ export { createDelegationTrackerHook } from './delegation-tracker';
 export { extractCurrentPhase, extractCurrentTask, extractDecisions, extractIncompleteTasks, extractPatterns, } from './extractors';
 export { createPipelineTrackerHook } from './pipeline-tracker';
 export { createSystemEnhancerHook } from './system-enhancer';
-export { composeHandlers, estimateTokens, readSwarmFileAsync, safeHook, } from './utils';
+export { composeHandlers, estimateTokens, readSwarmFileAsync, safeHook, validateSwarmPath, } from './utils';

package/dist/hooks/utils.d.ts

@@ -7,5 +7,14 @@
  */
 export declare function safeHook<I, O>(fn: (input: I, output: O) => Promise<void>): (input: I, output: O) => Promise<void>;
 export declare function composeHandlers<I, O>(...fns: Array<(input: I, output: O) => Promise<void>>): (input: I, output: O) => Promise<void>;
+/**
+ * Validates that a filename is safe to use within the .swarm directory
+ *
+ * @param directory - The base directory containing the .swarm folder
+ * @param filename - The filename to validate
+ * @returns The resolved absolute path if validation passes
+ * @throws Error if the filename is invalid or attempts path traversal
+ */
+export declare function validateSwarmPath(directory: string, filename: string): string;
 export declare function readSwarmFileAsync(directory: string, filename: string): Promise<string | null>;
 export declare function estimateTokens(text: string): number;

package/dist/index.js

@@ -13603,11 +13603,17 @@ import * as os from "os";
 import * as path from "path";
 var CONFIG_FILENAME = "opencode-swarm.json";
 var PROMPTS_DIR_NAME = "opencode-swarm";
+var MAX_CONFIG_FILE_BYTES = 102400;
 function getUserConfigDir() {
   return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
 }
 function loadConfigFromPath(configPath) {
   try {
+    const stats = fs.statSync(configPath);
+    if (stats.size > MAX_CONFIG_FILE_BYTES) {
+      console.warn(`[opencode-swarm] Config file too large (max 100 KB): ${configPath}`);
+      return null;
+    }
     const content = fs.readFileSync(configPath, "utf-8");
     const rawConfig = JSON.parse(content);
     const result = PluginConfigSchema.safeParse(rawConfig);
@@ -13624,23 +13630,30 @@ function loadConfigFromPath(configPath) {
     return null;
   }
 }
-function deepMerge(base, override) {
-  if (!base)
-    return override;
-  if (!override)
-    return base;
+var MAX_MERGE_DEPTH = 10;
+function deepMergeInternal(base, override, depth) {
+  if (depth >= MAX_MERGE_DEPTH) {
+    throw new Error(`deepMerge exceeded maximum depth of ${MAX_MERGE_DEPTH}`);
+  }
   const result = { ...base };
   for (const key of Object.keys(override)) {
     const baseVal = base[key];
     const overrideVal = override[key];
     if (typeof baseVal === "object" && baseVal !== null && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(baseVal) && !Array.isArray(overrideVal)) {
-      result[key] = deepMerge(baseVal, overrideVal);
+      result[key] = deepMergeInternal(baseVal, overrideVal, depth + 1);
     } else {
       result[key] = overrideVal;
     }
   }
   return result;
 }
+function deepMerge(base, override) {
+  if (!base)
+    return override;
+  if (!override)
+    return base;
+  return deepMergeInternal(base, override, 0);
+}
 function loadPluginConfig(directory) {
   const userConfigPath = path.join(getUserConfigDir(), "opencode", CONFIG_FILENAME);
   const projectConfigPath = path.join(directory, ".opencode", CONFIG_FILENAME);
@@ -14397,6 +14410,46 @@ function handleAgentsCommand(agents) {
 `);
 }
 
+// src/commands/config.ts
+import * as os2 from "os";
+import * as path2 from "path";
+function getUserConfigDir2() {
+  return process.env.XDG_CONFIG_HOME || path2.join(os2.homedir(), ".config");
+}
+async function handleConfigCommand(directory, _args) {
+  const config2 = loadPluginConfig(directory);
+  const userConfigPath = path2.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path2.join(directory, ".opencode", "opencode-swarm.json");
+  const lines = [
+    "## Swarm Configuration",
+    "",
+    "### Config Files",
+    `- User: \`${userConfigPath}\``,
+    `- Project: \`${projectConfigPath}\``,
+    "",
+    "### Resolved Config",
+    "```json",
+    JSON.stringify(config2, null, 2),
+    "```"
+  ];
+  return lines.join(`
+`);
+}
+
+// src/hooks/utils.ts
+import * as path3 from "path";
+
+// src/utils/errors.ts
+class SwarmError extends Error {
+  code;
+  guidance;
+  constructor(message, code, guidance) {
+    super(message);
+    this.name = "SwarmError";
+    this.code = code;
+    this.guidance = guidance;
+  }
+}
 // src/utils/logger.ts
 var DEBUG = process.env.OPENCODE_SWARM_DEBUG === "1";
 function log(message, data) {
@@ -14424,7 +14477,12 @@ function safeHook(fn) {
       await fn(input, output);
     } catch (_error) {
       const functionName = fn.name || "unknown";
-      warn(`Hook function '${functionName}' failed:`, _error);
+      if (_error instanceof SwarmError) {
+        warn(`Hook '${functionName}' failed: ${_error.message}
+  \u2192 ${_error.guidance}`);
+      } else {
+        warn(`Hook function '${functionName}' failed:`, _error);
+      }
     }
   };
 }
@@ -14439,10 +14497,30 @@ function composeHandlers(...fns) {
     }
   };
 }
+function validateSwarmPath(directory, filename) {
+  if (/[\0]/.test(filename)) {
+    throw new Error("Invalid filename: contains null bytes");
+  }
+  if (/\.\.[/\\]/.test(filename)) {
+    throw new Error("Invalid filename: path traversal detected");
+  }
+  const baseDir = path3.normalize(path3.resolve(directory, ".swarm"));
+  const resolved = path3.normalize(path3.resolve(baseDir, filename));
+  if (process.platform === "win32") {
+    if (!resolved.toLowerCase().startsWith((baseDir + path3.sep).toLowerCase())) {
+      throw new Error("Invalid filename: path escapes .swarm directory");
+    }
+  } else {
+    if (!resolved.startsWith(baseDir + path3.sep)) {
+      throw new Error("Invalid filename: path escapes .swarm directory");
+    }
+  }
+  return resolved;
+}
 async function readSwarmFileAsync(directory, filename) {
-  const path2 = `${directory}/.swarm/${filename}`;
   try {
-    const file2 = Bun.file(path2);
+    const resolvedPath = validateSwarmPath(directory, filename);
+    const file2 = Bun.file(resolvedPath);
     const content = await file2.text();
     return content;
   } catch {
@@ -14456,6 +14534,57 @@ function estimateTokens(text) {
   return Math.ceil(text.length * 0.33);
 }
 
+// src/commands/history.ts
+async function handleHistoryCommand(directory, _args) {
+  const planContent = await readSwarmFileAsync(directory, "plan.md");
+  if (!planContent) {
+    return "No history available.";
+  }
+  const phaseRegex = /^## Phase (\d+):?\s*(.+?)(?:\s*\[(COMPLETE|IN PROGRESS|PENDING)\])?\s*$/gm;
+  const phases = [];
+  const lines = planContent.split(`
+`);
+  for (let match = phaseRegex.exec(planContent);match !== null; match = phaseRegex.exec(planContent)) {
+    const num = parseInt(match[1], 10);
+    const name = match[2].trim();
+    const status = match[3] || "PENDING";
+    const headerLineIndex = lines.indexOf(match[0]);
+    let completed = 0;
+    let total = 0;
+    if (headerLineIndex !== -1) {
+      for (let i = headerLineIndex + 1;i < lines.length; i++) {
+        const line = lines[i];
+        if (/^## Phase \d+/.test(line) || line.trim() === "---" && total > 0) {
+          break;
+        }
+        if (/^- \[x\]/.test(line)) {
+          completed++;
+          total++;
+        } else if (/^- \[ \]/.test(line)) {
+          total++;
+        }
+      }
+    }
+    phases.push({ num, name, status, completed, total });
+  }
+  if (phases.length === 0) {
+    return "No history available.";
+  }
+  const tableLines = [
+    "## Swarm History",
+    "",
+    "| Phase | Name | Status | Tasks |",
+    "|-------|------|--------|-------|"
+  ];
+  for (const phase of phases) {
+    const statusIcon = phase.status === "COMPLETE" ? "\u2705" : phase.status === "IN PROGRESS" ? "\uD83D\uDD04" : "\u23F3";
+    const tasks = phase.total > 0 ? `${phase.completed}/${phase.total}` : "-";
+    tableLines.push(`| ${phase.num} | ${phase.name} | ${statusIcon} ${phase.status} | ${tasks} |`);
+  }
+  return tableLines.join(`
+`);
+}
+
 // src/commands/plan.ts
 async function handlePlanCommand(directory, args) {
   const planContent = await readSwarmFileAsync(directory, "plan.md");
@@ -14673,7 +14802,9 @@ var HELP_TEXT = [
   "",
   "- `/swarm status` \u2014 Show current swarm state",
   "- `/swarm plan [phase]` \u2014 Show plan (optionally filter by phase number)",
-  "- `/swarm agents` \u2014 List registered agents"
+  "- `/swarm agents` \u2014 List registered agents",
+  "- `/swarm history` \u2014 Show completed phases summary",
+  "- `/swarm config` \u2014 Show current resolved configuration"
 ].join(`
 `);
 function createSwarmCommandHandler(directory, agents) {
@@ -14694,6 +14825,12 @@ function createSwarmCommandHandler(directory, agents) {
       case "agents":
         text = handleAgentsCommand(agents);
         break;
+      case "history":
+        text = await handleHistoryCommand(directory, args);
+        break;
+      case "config":
+        text = await handleConfigCommand(directory, args);
+        break;
       default:
         text = HELP_TEXT;
         break;
@@ -14781,8 +14918,8 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path2 = `${directory}/.swarm/context.md`;
-    await Bun.write(path2, updated);
+    const path4 = `${directory}/.swarm/context.md`;
+    await Bun.write(path4, updated);
     swarmState.pendingEvents = Math.max(0, swarmState.pendingEvents - flushedCount);
   } catch (error49) {
     warn("Agent activity flush failed:", error49);
@@ -15801,10 +15938,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path2) {
-  if (!path2)
+function getElementAtPath2(obj, path4) {
+  if (!path4)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -16163,11 +16300,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path2, issues) {
+function prefixIssues2(path4, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -16335,7 +16472,7 @@ function treeifyError2(error49, _mapper) {
     return issue3.message;
   };
   const result = { errors: [] };
-  const processError = (error50, path2 = []) => {
+  const processError = (error50, path4 = []) => {
     var _a2, _b;
     for (const issue3 of error50.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -16345,7 +16482,7 @@ function treeifyError2(error49, _mapper) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path2, ...issue3.path];
+        const fullpath = [...path4, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -16377,8 +16514,8 @@ function treeifyError2(error49, _mapper) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -27574,7 +27711,7 @@ Use these as DOMAIN values when delegating to @sme.`;
 });
 // src/tools/file-extractor.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path4 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -27652,12 +27789,12 @@ var extract_code_blocks = tool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path2.join(targetDir, filename);
-      const base = path2.basename(filepath, path2.extname(filepath));
-      const ext = path2.extname(filepath);
+      let filepath = path4.join(targetDir, filename);
+      const base = path4.basename(filepath, path4.extname(filepath));
+      const ext = path4.extname(filepath);
       let counter = 1;
       while (fs2.existsSync(filepath)) {
-        filepath = path2.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path4.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -27686,26 +27823,73 @@ Errors:
   }
 });
 // src/tools/gitingest.ts
+var GITINGEST_TIMEOUT_MS = 1e4;
+var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
+var GITINGEST_MAX_RETRIES = 2;
+var delay = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 async function fetchGitingest(args) {
-  const response = await fetch("https://gitingest.com/api/ingest", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      input_text: args.url,
-      max_file_size: args.maxFileSize ?? 50000,
-      pattern: args.pattern ?? "",
-      pattern_type: args.patternType ?? "exclude"
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`gitingest API error: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  return `${data.summary}
+  for (let attempt = 0;attempt <= GITINGEST_MAX_RETRIES; attempt++) {
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), GITINGEST_TIMEOUT_MS);
+      const response = await fetch("https://gitingest.com/api/ingest", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          input_text: args.url,
+          max_file_size: args.maxFileSize ?? 50000,
+          pattern: args.pattern ?? "",
+          pattern_type: args.patternType ?? "exclude"
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status >= 500 && attempt < GITINGEST_MAX_RETRIES) {
+        const backoff = 200 * 2 ** attempt;
+        await delay(backoff);
+        continue;
+      }
+      if (response.status >= 400 && response.status < 500) {
+        throw new Error(`gitingest API error: ${response.status} ${response.statusText}`);
+      }
+      if (!response.ok) {
+        throw new Error(`gitingest API error: ${response.status} ${response.statusText}`);
+      }
+      const contentLength = Number(response.headers.get("content-length"));
+      if (Number.isFinite(contentLength) && contentLength > GITINGEST_MAX_RESPONSE_BYTES) {
+        throw new Error("gitingest response too large");
+      }
+      const text = await response.text();
+      if (Buffer.byteLength(text) > GITINGEST_MAX_RESPONSE_BYTES) {
+        throw new Error("gitingest response too large");
+      }
+      const data = JSON.parse(text);
+      return `${data.summary}
 
 ${data.tree}
 
 ${data.content}`;
+    } catch (error93) {
+      if (error93 instanceof DOMException && (error93.name === "TimeoutError" || error93.name === "AbortError")) {
+        if (attempt >= GITINGEST_MAX_RETRIES) {
+          throw new Error("gitingest request timed out");
+        }
+        const backoff = 200 * 2 ** attempt;
+        await delay(backoff);
+        continue;
+      }
+      if (error93 instanceof Error && error93.message.startsWith("gitingest ")) {
+        throw error93;
+      }
+      if (attempt < GITINGEST_MAX_RETRIES) {
+        const backoff = 200 * 2 ** attempt;
+        await delay(backoff);
+        continue;
+      }
+      throw error93;
+    }
+  }
+  throw new Error("gitingest request failed after retries");
 }
 var gitingest = tool({
   description: "Fetch a GitHub repository's full content via gitingest.com. Returns summary, directory tree, and file contents optimized for LLM analysis. Use when you need to understand an external repository's structure or code.",

package/dist/tools/gitingest.d.ts

@@ -5,8 +5,11 @@ export interface GitingestArgs {
     pattern?: string;
     patternType?: 'include' | 'exclude';
 }
+export declare const GITINGEST_TIMEOUT_MS = 10000;
+export declare const GITINGEST_MAX_RESPONSE_BYTES = 5242880;
+export declare const GITINGEST_MAX_RETRIES = 2;
 /**
- * Fetch repository content via gitingest.com API
+ * Fetch repository content via gitingest.com API with timeout, size guard, and retry logic
  */
 export declare function fetchGitingest(args: GitingestArgs): Promise<string>;
 /**

package/dist/utils/errors.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Base error class for all swarm errors.
+ * Includes a machine-readable `code` and a user-facing `guidance` string.
+ */
+export declare class SwarmError extends Error {
+    readonly code: string;
+    readonly guidance: string;
+    constructor(message: string, code: string, guidance: string);
+}
+/**
+ * Error thrown when configuration loading or validation fails.
+ */
+export declare class ConfigError extends SwarmError {
+    constructor(message: string, guidance: string);
+}
+/**
+ * Error thrown when a hook execution fails.
+ */
+export declare class HookError extends SwarmError {
+    constructor(message: string, guidance: string);
+}
+/**
+ * Error thrown when a tool execution fails.
+ */
+export declare class ToolError extends SwarmError {
+    constructor(message: string, guidance: string);
+}
+/**
+ * Error thrown when CLI operations fail.
+ */
+export declare class CLIError extends SwarmError {
+    constructor(message: string, guidance: string);
+}

package/dist/utils/index.d.ts

@@ -1 +1,2 @@
-export { log, warn, error } from './logger';
+export { CLIError, ConfigError, HookError, SwarmError, ToolError, } from './errors';
+export { error, log, warn } from './logger';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "4.3.1",
+	"version": "4.4.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -35,12 +35,12 @@
 		"prepublishOnly": "bun run build"
 	},
 	"dependencies": {
-		"@opencode-ai/plugin": "^1.1.19",
-		"@opencode-ai/sdk": "^1.1.19",
+		"@opencode-ai/plugin": "^1.1.53",
+		"@opencode-ai/sdk": "^1.1.53",
 		"zod": "^4.1.8"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.3.11",
+		"@biomejs/biome": "2.3.14",
 		"bun-types": "latest",
 		"typescript": "^5.7.3"
 	}