oh-my-opencode-slim 0.9.11 → 0.9.12

package/README.md

@@ -388,7 +388,7 @@ Slim only intercepts `apply_patch` before native execution. It rewrites recovera
   <p><sub>Every merged contribution leaves a mark on the realm.</sub></p>
 
   <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-35-orange.svg?style=flat-square)](#contributors-)
+[![All Contributors](https://img.shields.io/badge/all_contributors-36-orange.svg?style=flat-square)](#contributors-)
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 </div>
 
@@ -445,6 +445,7 @@ Slim only intercepts `apply_patch` before native execution. It rewrites recovera
       <td align="center" valign="top" width="16.66%"><a href="https://nettee.io/"><img src="https://avatars.githubusercontent.com/u/3953668?v=4?s=100" width="100px;" alt="nettee"/><br /><sub><b>nettee</b></sub></a><br /><a href="https://github.com/alvinunreal/oh-my-opencode-slim/commits?author=nettee" title="Code">💻</a></td>
       <td align="center" valign="top" width="16.66%"><a href="https://github.com/atomlink-ye"><img src="https://avatars.githubusercontent.com/u/48194045?v=4?s=100" width="100px;" alt="Link"/><br /><sub><b>Link</b></sub></a><br /><a href="https://github.com/alvinunreal/oh-my-opencode-slim/commits?author=atomlink-ye" title="Code">💻</a></td>
       <td align="center" valign="top" width="16.66%"><a href="https://github.com/blaszewski"><img src="https://avatars.githubusercontent.com/u/14119531?v=4?s=100" width="100px;" alt="Bartosz Łaszewski"/><br /><sub><b>Bartosz Łaszewski</b></sub></a><br /><a href="https://github.com/alvinunreal/oh-my-opencode-slim/commits?author=blaszewski" title="Code">💻</a></td>
+      <td align="center" valign="top" width="16.66%"><a href="https://github.com/huilang021x"><img src="https://avatars.githubusercontent.com/u/77293911?v=4?s=100" width="100px;" alt="huilang021x"/><br /><sub><b>huilang021x</b></sub></a><br /><a href="https://github.com/alvinunreal/oh-my-opencode-slim/commits?author=huilang021x" title="Code">💻</a></td>
     </tr>
   </tbody>
 </table>

package/dist/cli/index.js

@@ -13,7 +13,7 @@ import {
   statSync as statSync2,
   writeFileSync
 } from "fs";
-import { pathToFileURL } from "url";
+import { dirname as dirname3, join as join3 } from "path";
 
 // src/cli/paths.ts
 import { existsSync, mkdirSync } from "fs";
@@ -481,8 +481,49 @@ function generateLiteConfig(installConfig) {
 
 // src/cli/config-io.ts
 var PACKAGE_NAME = "oh-my-opencode-slim";
+function normalizePathForMatch(path) {
+  return path.replaceAll("\\", "/");
+}
+function findPackageRoot(startPath) {
+  let currentPath = dirname3(startPath);
+  while (true) {
+    const packageJsonPath = join3(currentPath, "package.json");
+    if (existsSync3(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (packageJson.name === PACKAGE_NAME) {
+          return currentPath;
+        }
+      } catch {}
+    }
+    const parentPath = dirname3(currentPath);
+    if (parentPath === currentPath) {
+      return null;
+    }
+    currentPath = parentPath;
+  }
+}
+function isPackageManagerInstall(path) {
+  const normalizedPath = normalizePathForMatch(path);
+  return normalizedPath.includes(`/node_modules/${PACKAGE_NAME}`);
+}
+function isLocalPackageRootEntry(entry) {
+  if (!entry || entry.startsWith("file://")) {
+    return false;
+  }
+  const packageJsonPath = join3(entry, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.name === PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
 function isPluginEntry(entry) {
-  return entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`) || entry.startsWith("file://") && entry.includes(PACKAGE_NAME);
+  return entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`) || entry.startsWith("file://") && entry.includes(PACKAGE_NAME) || isLocalPackageRootEntry(entry);
 }
 function getPluginEntry() {
   const cliEntryPath = process.argv[1];
@@ -490,11 +531,11 @@ function getPluginEntry() {
     return PACKAGE_NAME;
   }
   try {
-    const pluginEntryPath = cliEntryPath.match(/[\\/]dist[\\/]cli[\\/]index\.js$/) ? cliEntryPath.replace(/[\\/]dist[\\/]cli[\\/]index\.js$/, "/dist/index.js") : null;
-    if (!pluginEntryPath) {
+    const packageRoot = findPackageRoot(cliEntryPath);
+    if (!packageRoot || isPackageManagerInstall(packageRoot)) {
       return PACKAGE_NAME;
     }
-    return pathToFileURL(pluginEntryPath).href;
+    return packageRoot;
   } catch {
     return PACKAGE_NAME;
   }
@@ -684,8 +725,35 @@ function detectCurrentConfig() {
   return result;
 }
 // src/cli/system.ts
+import { spawnSync as spawnSync2 } from "child_process";
 import { statSync as statSync3 } from "fs";
 var cachedOpenCodePath = null;
+function resolvePathCommand(command) {
+  try {
+    const resolver = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync2(resolver, [command], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (result.status !== 0) {
+      return null;
+    }
+    const resolved = result.stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    return resolved ?? null;
+  } catch {
+    return null;
+  }
+}
+function canExecute(command, args) {
+  try {
+    const result = spawnSync2(command, args, {
+      stdio: "ignore"
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
 function getOpenCodePaths() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
   return [
@@ -721,6 +789,11 @@ function resolveOpenCodePath() {
   if (cachedOpenCodePath) {
     return cachedOpenCodePath;
   }
+  const pathOpenCodePath = resolvePathCommand("opencode");
+  if (pathOpenCodePath) {
+    cachedOpenCodePath = pathOpenCodePath;
+    return pathOpenCodePath;
+  }
   const paths = getOpenCodePaths();
   for (const opencodePath of paths) {
     if (opencodePath === "opencode")
@@ -736,33 +809,31 @@ function resolveOpenCodePath() {
   return "opencode";
 }
 async function isOpenCodeInstalled() {
+  const pathOpenCodePath = resolvePathCommand("opencode");
+  if (pathOpenCodePath && canExecute(pathOpenCodePath, ["--version"])) {
+    cachedOpenCodePath = pathOpenCodePath;
+    return true;
+  }
   const paths = getOpenCodePaths();
   for (const opencodePath of paths) {
-    try {
-      const proc = Bun.spawn([opencodePath, "--version"], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      await proc.exited;
-      if (proc.exitCode === 0) {
-        cachedOpenCodePath = opencodePath;
-        return true;
-      }
-    } catch {}
+    if (opencodePath === "opencode")
+      continue;
+    if (canExecute(opencodePath, ["--version"])) {
+      cachedOpenCodePath = opencodePath;
+      return true;
+    }
   }
   return false;
 }
 async function getOpenCodeVersion() {
   const opencodePath = resolveOpenCodePath();
   try {
-    const proc = Bun.spawn([opencodePath, "--version"], {
-      stdout: "pipe",
-      stderr: "pipe"
+    const result = spawnSync2(opencodePath, ["--version"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
     });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    if (proc.exitCode === 0) {
-      return output.trim();
+    if (result.status === 0) {
+      return result.stdout.trim();
     }
   } catch {}
   return null;

package/dist/hooks/apply-patch/execution-context.d.ts

@@ -21,10 +21,7 @@ export type ResolvedPreparedUpdate = {
     nextText: string;
 };
 export declare function isMissingPathError(error: unknown): boolean;
-export declare function parseValidatedPatch(root: string, patchText: string, worktree?: string): Promise<{
-    hunks: PatchHunk[];
-    pathsNormalized: boolean;
-}>;
+export declare function parseValidatedPatch(patchText: string): PatchHunk[];
 export declare function createPatchExecutionContext(root: string, patchText: string, worktree?: string): Promise<PatchExecutionContext>;
 export declare function resolvePreparedUpdate(filePath: string, currentText: string, hunk: UpdatePatchHunk, cfg: ApplyPatchRuntimeOptions): ResolvedPreparedUpdate;
 export declare function stageAddedText(contents: string): string;

package/dist/hooks/auto-update-checker/cache.d.ts

@@ -1,6 +1,11 @@
+interface AutoUpdateInstallContext {
+    installDir: string;
+    packageJsonPath: string;
+}
+export declare function resolveInstallContext(runtimePackageJsonPath?: string | null): AutoUpdateInstallContext | null;
 /**
- * Invalidates the current package by removing its directory and dependency entries.
- * This forces a clean state before running a fresh install.
- * @param packageName The name of the package to invalidate.
+ * Prepares the current install root for a clean re-install of the target version.
+ * Returns the install directory to run `bun install` in.
  */
-export declare function invalidatePackage(packageName?: string): boolean;
+export declare function preparePackageUpdate(version: string, packageName?: string, runtimePackageJsonPath?: string | null): string | null;
+export {};

package/dist/hooks/auto-update-checker/checker.d.ts

@@ -9,6 +9,10 @@ export declare function extractChannel(version: string | null): string;
  * Resolves the version of the plugin when running in local development mode.
  */
 export declare function getLocalDevVersion(directory: string): string | null;
+/**
+ * Resolves the package.json for the currently running plugin bundle.
+ */
+export declare function getCurrentRuntimePackageJsonPath(currentModuleUrl?: string): string | null;
 /**
  * Searches across all config locations to find the current installation entry for this plugin.
  */

package/dist/hooks/todo-continuation/index.d.ts

@@ -6,6 +6,15 @@ export declare function createTodoContinuationHook(ctx: PluginInput, config?: {
     autoEnableThreshold?: number;
 }): {
     tool: Record<string, unknown>;
+    handleToolExecuteAfter: (input: {
+        tool: string;
+        sessionID?: string;
+    }) => Promise<void>;
+    handleChatSystemTransform: (input: {
+        sessionID?: string;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
     handleEvent: (input: {
         event: {
             type: string;

package/dist/hooks/todo-continuation/todo-hygiene.d.ts

@@ -0,0 +1,37 @@
+export declare const TODO_HYGIENE_REMINDER = "If the active task changed or finished, update the todo list to match the current work state.";
+export declare const TODO_FINAL_ACTIVE_REMINDER = "If you are finishing now, do not leave the active todo in_progress. Mark it completed, or move unfinished work back to pending.";
+interface ToolInput {
+    tool: string;
+    sessionID?: string;
+}
+interface SystemInput {
+    sessionID?: string;
+}
+interface SystemOutput {
+    system: string[];
+}
+interface EventInput {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+        };
+        sessionID?: string;
+    };
+}
+interface Options {
+    getTodoState: (sessionID: string) => Promise<{
+        hasOpenTodos: boolean;
+        openCount: number;
+        inProgressCount: number;
+        pendingCount: number;
+    }>;
+    shouldInject?: (sessionID: string) => boolean;
+    log?: (message: string, meta?: Record<string, unknown>) => void;
+}
+export declare function createTodoHygiene(options: Options): {
+    handleToolExecuteAfter(input: ToolInput): Promise<void>;
+    handleChatSystemTransform(input: SystemInput, output: SystemOutput): Promise<void>;
+    handleEvent(event: EventInput): void;
+};
+export {};

package/dist/index.js

@@ -3906,44 +3906,19 @@ function collectPatchTargets(root, hunks) {
   }
   return [...targets];
 }
-function validatePatchPaths(hunks) {
-  for (const hunk of hunks) {
-    if (path3.isAbsolute(hunk.path)) {
-      throw createApplyPatchValidationError(`absolute patch paths are not allowed: ${hunk.path}`);
-    }
-    if (hunk.type === "update" && hunk.move_path && path3.isAbsolute(hunk.move_path)) {
-      throw createApplyPatchValidationError(`absolute patch paths are not allowed: ${hunk.move_path}`);
-    }
-  }
-}
-function toPortablePatchPath(filePath) {
-  return filePath.split(path3.sep).join("/");
-}
 function toRelativePatchPath(root, target) {
   const relative = path3.relative(root, target);
-  return toPortablePatchPath(relative.length === 0 ? path3.basename(target) : relative);
+  return (relative.length === 0 ? "." : relative).replaceAll("\\", "/");
 }
-async function normalizeAbsolutePatchPath(root, worktree, value) {
-  if (!path3.isAbsolute(value)) {
-    return value;
-  }
-  const guardContext = createPathGuardContext(root, worktree);
-  const target = path3.resolve(value);
-  await guard(guardContext, target);
-  const [rootReal, targetReal] = await Promise.all([
-    guardContext.rootReal,
-    realCached(guardContext, target)
-  ]);
-  if (!inside(rootReal, targetReal)) {
-    throw createApplyPatchBlockedError(`patch contains path outside workspace root: ${target}`);
-  }
-  return toRelativePatchPath(root, target);
+function normalizePatchPath(root, value) {
+  return path3.isAbsolute(value) ? toRelativePatchPath(root, path3.resolve(value)) : value;
 }
-async function normalizeAbsolutePatchPaths(root, worktree, hunks) {
+function normalizePatchPaths(root, hunks) {
+  const resolvedRoot = path3.resolve(root);
   const normalized = [];
   let changed = false;
   for (const hunk of hunks) {
-    const normalizedPath = await normalizeAbsolutePatchPath(root, worktree, hunk.path);
+    const normalizedPath = normalizePatchPath(resolvedRoot, hunk.path);
     if (hunk.type !== "update") {
       changed ||= normalizedPath !== hunk.path;
       normalized.push(normalizedPath === hunk.path ? hunk : {
@@ -3952,7 +3927,7 @@ async function normalizeAbsolutePatchPaths(root, worktree, hunks) {
       });
       continue;
     }
-    const normalizedMovePath = hunk.move_path ? await normalizeAbsolutePatchPath(root, worktree, hunk.move_path) : undefined;
+    const normalizedMovePath = hunk.move_path ? normalizePatchPath(resolvedRoot, hunk.move_path) : undefined;
     changed ||= normalizedPath !== hunk.path || normalizedMovePath !== hunk.move_path;
     normalized.push(normalizedPath === hunk.path && normalizedMovePath === hunk.move_path ? hunk : {
       ...hunk,
@@ -3969,7 +3944,7 @@ async function guardPatchTargets(root, worktree, targets) {
   }
   return targets.length;
 }
-async function parseValidatedPatch(root, patchText, worktree) {
+function parseValidatedPatch(patchText) {
   let hunks;
   try {
     hunks = parsePatchStrict(patchText).hunks;
@@ -3986,12 +3961,7 @@ async function parseValidatedPatch(root, patchText, worktree) {
     }
     throw createApplyPatchValidationError("no hunks found");
   }
-  const normalizedPatch = await normalizeAbsolutePatchPaths(root, worktree, hunks);
-  validatePatchPaths(normalizedPatch.hunks);
-  return {
-    hunks: normalizedPatch.hunks,
-    pathsNormalized: normalizedPatch.changed
-  };
+  return hunks;
 }
 async function readPreparedFileText(filePath, verb) {
   try {
@@ -4004,8 +3974,9 @@ async function readPreparedFileText(filePath, verb) {
   }
 }
 async function createPatchExecutionContext(root, patchText, worktree) {
-  const { hunks, pathsNormalized } = await parseValidatedPatch(root, patchText, worktree);
-  await guardPatchTargets(root, worktree, collectPatchTargets(root, hunks));
+  const parsedHunks = parseValidatedPatch(patchText);
+  await guardPatchTargets(root, worktree, collectPatchTargets(root, parsedHunks));
+  const normalized = normalizePatchPaths(root, parsedHunks);
   const files = createFileCacheContext();
   const staged = new Map;
   async function assertPreparedPathMissing(filePath, verb) {
@@ -4043,8 +4014,8 @@ async function createPatchExecutionContext(root, patchText, worktree) {
     return state;
   }
   return {
-    hunks,
-    pathsNormalized,
+    hunks: normalized.hunks,
+    pathsNormalized: normalized.changed,
     staged,
     getPreparedFileState,
     assertPreparedPathMissing
@@ -4233,6 +4204,9 @@ async function rewritePatch(root, patchText, cfg, worktree) {
     let rewrittenChunks = 0;
     const rewriteModes = new Set;
     const totalChunks = hunks.reduce((count, hunk) => count + (hunk.type === "update" ? hunk.chunks.length : 0), 0);
+    if (pathsNormalized) {
+      rewriteModes.add("normalize:patch-paths");
+    }
     const dependencyGroups = new Map;
     for (const hunk of hunks) {
       if (hunk.type === "add") {
@@ -4352,7 +4326,7 @@ async function rewritePatch(root, patchText, cfg, worktree) {
           changed: true,
           rewrittenChunks: 0,
           totalChunks,
-          rewriteModes: ["normalize:patch-paths"]
+          rewriteModes: [...rewriteModes].sort()
         };
       }
       if (normalizedPatchText !== patchText) {
@@ -4435,8 +4409,13 @@ function createApplyPatchHook(ctx) {
   };
 }
 // src/hooks/auto-update-checker/cache.ts
+import * as fs5 from "fs";
+import * as path7 from "path";
+// src/hooks/auto-update-checker/checker.ts
 import * as fs4 from "fs";
 import * as path6 from "path";
+import { fileURLToPath } from "url";
+
 // src/hooks/auto-update-checker/constants.ts
 import * as os2 from "os";
 import * as path5 from "path";
@@ -4455,80 +4434,7 @@ var configPaths = getOpenCodeConfigPaths();
 var USER_OPENCODE_CONFIG = configPaths[0];
 var USER_OPENCODE_CONFIG_JSONC = configPaths[1];
 
-// src/hooks/auto-update-checker/cache.ts
-function removeFromBunLock(packageName) {
-  const lockPath = path6.join(CACHE_DIR, "bun.lock");
-  if (!fs4.existsSync(lockPath))
-    return false;
-  try {
-    const content = fs4.readFileSync(lockPath, "utf-8");
-    let lock;
-    try {
-      lock = JSON.parse(stripJsonComments(content));
-    } catch {
-      return false;
-    }
-    let modified = false;
-    if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
-      delete lock.workspaces[""].dependencies[packageName];
-      modified = true;
-    }
-    if (lock.packages?.[packageName]) {
-      delete lock.packages[packageName];
-      modified = true;
-    }
-    if (modified) {
-      fs4.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
-      log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
-    }
-    return modified;
-  } catch (err) {
-    log(`[auto-update-checker] Failed to process bun.lock:`, err);
-    return false;
-  }
-}
-function invalidatePackage(packageName = PACKAGE_NAME) {
-  try {
-    const pkgDir = path6.join(CACHE_DIR, "node_modules", packageName);
-    const pkgJsonPath = path6.join(CACHE_DIR, "package.json");
-    let packageRemoved = false;
-    let dependencyRemoved = false;
-    let lockRemoved = false;
-    if (fs4.existsSync(pkgDir)) {
-      fs4.rmSync(pkgDir, { recursive: true, force: true });
-      log(`[auto-update-checker] Package removed: ${pkgDir}`);
-      packageRemoved = true;
-    }
-    if (fs4.existsSync(pkgJsonPath)) {
-      try {
-        const content = fs4.readFileSync(pkgJsonPath, "utf-8");
-        const pkgJson = JSON.parse(stripJsonComments(content));
-        if (pkgJson.dependencies?.[packageName]) {
-          delete pkgJson.dependencies[packageName];
-          fs4.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
-          log(`[auto-update-checker] Dependency removed from package.json: ${packageName}`);
-          dependencyRemoved = true;
-        }
-      } catch (err) {
-        log(`[auto-update-checker] Failed to update package.json for invalidation:`, err);
-      }
-    }
-    lockRemoved = removeFromBunLock(packageName);
-    if (!packageRemoved && !dependencyRemoved && !lockRemoved) {
-      log(`[auto-update-checker] Package not found, nothing to invalidate: ${packageName}`);
-      return false;
-    }
-    return true;
-  } catch (err) {
-    log("[auto-update-checker] Failed to invalidate package:", err);
-    return false;
-  }
-}
-
 // src/hooks/auto-update-checker/checker.ts
-import * as fs5 from "fs";
-import * as path7 from "path";
-import { fileURLToPath } from "url";
 function isPrereleaseVersion(version) {
   return version.includes("-");
 }
@@ -4552,8 +4458,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    path7.join(directory, ".opencode", "opencode.json"),
-    path7.join(directory, ".opencode", "opencode.jsonc"),
+    path6.join(directory, ".opencode", "opencode.json"),
+    path6.join(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -4561,9 +4467,9 @@ function getConfigPaths(directory) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs5.existsSync(configPath))
+      if (!fs4.existsSync(configPath))
         continue;
-      const content = fs5.readFileSync(configPath, "utf-8");
+      const content = fs4.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -4581,19 +4487,19 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat2 = fs5.statSync(startPath);
-    let dir = stat2.isDirectory() ? startPath : path7.dirname(startPath);
+    const stat2 = fs4.statSync(startPath);
+    let dir = stat2.isDirectory() ? startPath : path6.dirname(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = path7.join(dir, "package.json");
-      if (fs5.existsSync(pkgPath)) {
+      const pkgPath = path6.join(dir, "package.json");
+      if (fs4.existsSync(pkgPath)) {
         try {
-          const content = fs5.readFileSync(pkgPath, "utf-8");
+          const content = fs4.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
           if (pkg.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
       }
-      const parent = path7.dirname(dir);
+      const parent = path6.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -4609,19 +4515,28 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const content = fs5.readFileSync(pkgPath, "utf-8");
+    const content = fs4.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version ?? null;
   } catch {
     return null;
   }
 }
+function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
+  try {
+    const currentDir = path6.dirname(fileURLToPath(currentModuleUrl));
+    return findPackageJsonUp(currentDir);
+  } catch (err) {
+    log("[auto-update-checker] Failed to resolve runtime package path:", err);
+    return null;
+  }
+}
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs5.existsSync(configPath))
+      if (!fs4.existsSync(configPath))
         continue;
-      const content = fs5.readFileSync(configPath, "utf-8");
+      const content = fs4.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -4648,8 +4563,9 @@ function getCachedVersion() {
   if (cachedPackageVersion)
     return cachedPackageVersion;
   try {
-    if (fs5.existsSync(INSTALLED_PACKAGE_JSON)) {
-      const content = fs5.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+    const runtimePackageJsonPath = getCurrentRuntimePackageJsonPath();
+    if (runtimePackageJsonPath && fs4.existsSync(runtimePackageJsonPath)) {
+      const content = fs4.readFileSync(runtimePackageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version) {
         cachedPackageVersion = pkg.version;
@@ -4658,10 +4574,8 @@ function getCachedVersion() {
     }
   } catch {}
   try {
-    const currentDir = path7.dirname(fileURLToPath(import.meta.url));
-    const pkgPath = findPackageJsonUp(currentDir);
-    if (pkgPath) {
-      const content = fs5.readFileSync(pkgPath, "utf-8");
+    if (fs4.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs4.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version) {
         cachedPackageVersion = pkg.version;
@@ -4692,6 +4606,108 @@ async function getLatestVersion(channel = "latest") {
   }
 }
 
+// src/hooks/auto-update-checker/cache.ts
+function removeFromBunLock(installDir, packageName) {
+  const lockPath = path7.join(installDir, "bun.lock");
+  if (!fs5.existsSync(lockPath))
+    return false;
+  try {
+    const content = fs5.readFileSync(lockPath, "utf-8");
+    let lock;
+    try {
+      lock = JSON.parse(stripJsonComments(content));
+    } catch {
+      return false;
+    }
+    let modified = false;
+    if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
+      delete lock.workspaces[""].dependencies[packageName];
+      modified = true;
+    }
+    if (lock.packages?.[packageName]) {
+      delete lock.packages[packageName];
+      modified = true;
+    }
+    if (modified) {
+      fs5.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+      log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
+    }
+    return modified;
+  } catch (err) {
+    log(`[auto-update-checker] Failed to process bun.lock:`, err);
+    return false;
+  }
+}
+function ensureDependencyVersion(packageJsonPath, packageName, version) {
+  if (!fs5.existsSync(packageJsonPath))
+    return false;
+  try {
+    const content = fs5.readFileSync(packageJsonPath, "utf-8");
+    const pkgJson = JSON.parse(stripJsonComments(content));
+    const dependencies = { ...pkgJson.dependencies ?? {} };
+    if (dependencies[packageName] === version) {
+      return true;
+    }
+    dependencies[packageName] = version;
+    pkgJson.dependencies = dependencies;
+    fs5.writeFileSync(packageJsonPath, JSON.stringify(pkgJson, null, 2));
+    log(`[auto-update-checker] Updated dependency in package.json: ${packageName} \u2192 ${version}`);
+    return true;
+  } catch (err) {
+    log(`[auto-update-checker] Failed to update package.json dependency for auto-update:`, err);
+    return false;
+  }
+}
+function removeInstalledPackage(installDir, packageName) {
+  const pkgDir = path7.join(installDir, "node_modules", packageName);
+  if (!fs5.existsSync(pkgDir))
+    return false;
+  fs5.rmSync(pkgDir, { recursive: true, force: true });
+  log(`[auto-update-checker] Package removed: ${pkgDir}`);
+  return true;
+}
+function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
+  if (runtimePackageJsonPath) {
+    const packageDir = path7.dirname(runtimePackageJsonPath);
+    const nodeModulesDir = path7.dirname(packageDir);
+    if (path7.basename(packageDir) === PACKAGE_NAME && path7.basename(nodeModulesDir) === "node_modules") {
+      const installDir = path7.dirname(nodeModulesDir);
+      const packageJsonPath = path7.join(installDir, "package.json");
+      if (fs5.existsSync(packageJsonPath)) {
+        return { installDir, packageJsonPath };
+      }
+    }
+    return null;
+  }
+  const legacyPackageJsonPath = path7.join(CACHE_DIR, "package.json");
+  if (fs5.existsSync(legacyPackageJsonPath)) {
+    return { installDir: CACHE_DIR, packageJsonPath: legacyPackageJsonPath };
+  }
+  return null;
+}
+function preparePackageUpdate(version, packageName = PACKAGE_NAME, runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
+  try {
+    const installContext = resolveInstallContext(runtimePackageJsonPath);
+    if (!installContext) {
+      log("[auto-update-checker] No install context found for auto-update");
+      return null;
+    }
+    const dependencyReady = ensureDependencyVersion(installContext.packageJsonPath, packageName, version);
+    if (!dependencyReady) {
+      return null;
+    }
+    const packageRemoved = removeInstalledPackage(installContext.installDir, packageName);
+    const lockRemoved = removeFromBunLock(installContext.installDir, packageName);
+    if (!packageRemoved && !lockRemoved) {
+      log(`[auto-update-checker] No cached package artifacts removed for ${packageName}; continuing with updated dependency spec`);
+    }
+    return installContext.installDir;
+  } catch (err) {
+    log("[auto-update-checker] Failed to prepare package update:", err);
+    return null;
+  }
+}
+
 // src/hooks/auto-update-checker/index.ts
 function createAutoUpdateCheckerHook(ctx, options = {}) {
   const { showStartupToast = true, autoUpdate = true } = options;
@@ -4761,23 +4777,24 @@ Version is pinned. Update your plugin config to apply.`, "info", 8000);
     log("[auto-update-checker] Auto-update disabled, notification only");
     return;
   }
-  invalidatePackage(PACKAGE_NAME);
-  const installSuccess = await runBunInstallSafe();
+  const installDir = preparePackageUpdate(latestVersion, PACKAGE_NAME);
+  if (!installDir) {
+    showToast(ctx, `OMO-Slim ${latestVersion}`, `v${latestVersion} available. Auto-update could not prepare the active install.`, "info", 8000);
+    log("[auto-update-checker] Failed to prepare install root for auto-update");
+    return;
+  }
+  const installSuccess = await runBunInstallSafe(installDir);
   if (installSuccess) {
     showToast(ctx, "OMO-Slim Updated!", `v${currentVersion} \u2192 v${latestVersion}
 Restart OpenCode to apply.`, "success", 8000);
     log(`[auto-update-checker] Update installed: ${currentVersion} \u2192 ${latestVersion}`);
   } else {
-    showToast(ctx, `OMO-Slim ${latestVersion}`, `v${latestVersion} available. Restart to apply.`, "info", 8000);
+    showToast(ctx, `OMO-Slim ${latestVersion}`, `v${latestVersion} available, but auto-update failed to install it. Check logs or retry manually.`, "error", 8000);
     log("[auto-update-checker] bun install failed; update not installed");
   }
 }
-function getAutoUpdateInstallDir() {
-  return CACHE_DIR;
-}
-async function runBunInstallSafe() {
+async function runBunInstallSafe(installDir) {
   try {
-    const installDir = getAutoUpdateInstallDir();
     const proc = Bun.spawn(["bun", "install"], {
       cwd: installDir,
       stdout: "pipe",
@@ -5370,6 +5387,126 @@ function createPostFileToolNudgeHook(options = {}) {
 }
 // src/hooks/todo-continuation/index.ts
 import { tool } from "@opencode-ai/plugin/tool";
+
+// src/hooks/todo-continuation/todo-hygiene.ts
+var TODO_HYGIENE_REMINDER = "If the active task changed or finished, update the todo list to match the current work state.";
+var TODO_FINAL_ACTIVE_REMINDER = "If you are finishing now, do not leave the active todo in_progress. Mark it completed, or move unfinished work back to pending.";
+var RESET = new Set(["todowrite"]);
+var IGNORE = new Set(["auto_continue"]);
+function createTodoHygiene(options) {
+  const pending = new Set;
+  const done = new Set;
+  function clear(sessionID) {
+    pending.delete(sessionID);
+    done.delete(sessionID);
+  }
+  function isFinalActive(state) {
+    return state.inProgressCount === 1 && state.pendingCount === 0 && state.openCount === 1;
+  }
+  return {
+    async handleToolExecuteAfter(input) {
+      if (!input.sessionID) {
+        return;
+      }
+      const tool = input.tool.toLowerCase();
+      if (IGNORE.has(tool)) {
+        return;
+      }
+      try {
+        if (RESET.has(tool)) {
+          const state = await options.getTodoState(input.sessionID);
+          if (!state.hasOpenTodos) {
+            clear(input.sessionID);
+            options.log?.("Cleared todo hygiene cycle", {
+              sessionID: input.sessionID,
+              tool
+            });
+            return;
+          }
+          pending.delete(input.sessionID);
+          done.delete(input.sessionID);
+          if (isFinalActive(state)) {
+            pending.add(input.sessionID);
+            options.log?.("Armed final-active todo hygiene reminder", {
+              sessionID: input.sessionID,
+              tool
+            });
+            return;
+          }
+          options.log?.("Reset todo hygiene cycle", {
+            sessionID: input.sessionID,
+            tool
+          });
+          return;
+        }
+        if (pending.has(input.sessionID) || done.has(input.sessionID)) {
+          return;
+        }
+        if (!(await options.getTodoState(input.sessionID)).hasOpenTodos) {
+          return;
+        }
+        pending.add(input.sessionID);
+        options.log?.("Armed todo hygiene reminder", {
+          sessionID: input.sessionID,
+          tool
+        });
+      } catch (error) {
+        if (RESET.has(tool)) {
+          clear(input.sessionID);
+        }
+        options.log?.("Skipped todo hygiene reminder: failed to inspect todos", {
+          sessionID: input.sessionID,
+          tool,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    },
+    async handleChatSystemTransform(input, output) {
+      if (!input.sessionID || !pending.has(input.sessionID)) {
+        return;
+      }
+      if (options.shouldInject && !options.shouldInject(input.sessionID)) {
+        pending.delete(input.sessionID);
+        done.add(input.sessionID);
+        return;
+      }
+      try {
+        const state = await options.getTodoState(input.sessionID);
+        if (!state.hasOpenTodos) {
+          clear(input.sessionID);
+          return;
+        }
+        const finalActive = isFinalActive(state);
+        const reminder = finalActive ? TODO_FINAL_ACTIVE_REMINDER : TODO_HYGIENE_REMINDER;
+        pending.delete(input.sessionID);
+        done.add(input.sessionID);
+        output.system.push(reminder);
+        options.log?.("Injected todo hygiene reminder", {
+          sessionID: input.sessionID,
+          reminder: finalActive ? "final-active" : "general"
+        });
+      } catch (error) {
+        clear(input.sessionID);
+        options.log?.("Skipped todo hygiene reminder: failed to inspect todos", {
+          sessionID: input.sessionID,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    },
+    handleEvent(event) {
+      if (event.type !== "session.deleted") {
+        return;
+      }
+      const sessionID = event.properties?.sessionID ?? event.properties?.info?.id;
+      if (!sessionID) {
+        return;
+      }
+      clear(sessionID);
+    }
+  };
+}
+
+// src/hooks/todo-continuation/index.ts
 var HOOK_NAME = "todo-continuation";
 var COMMAND_NAME = "auto-continue";
 var CONTINUATION_PROMPT = "[Auto-continue: enabled - there are incomplete todos remaining. Continue with the next uncompleted item. Press Esc to cancel. If you need user input or review for the next item, ask instead of proceeding.]";
@@ -5427,6 +5564,23 @@ function createTodoContinuationHook(ctx, config) {
     notifyingSessionIds: new Set,
     notificationBusyUntilBySession: new Map
   };
+  const hygiene = createTodoHygiene({
+    getTodoState: async (sessionID) => {
+      const result = await ctx.client.session.todo({
+        path: { id: sessionID }
+      });
+      const todos = result.data;
+      const openTodos = todos.filter((todo) => !TERMINAL_TODO_STATUSES.includes(todo.status));
+      return {
+        hasOpenTodos: openTodos.length > 0,
+        openCount: openTodos.length,
+        inProgressCount: openTodos.filter((todo) => todo.status === "in_progress").length,
+        pendingCount: openTodos.filter((todo) => todo.status === "pending").length
+      };
+    },
+    shouldInject: (sessionID) => isOrchestratorSession(sessionID),
+    log: (message, meta) => log(`[${HOOK_NAME}] ${message}`, meta)
+  });
   function markNotificationStarted(sessionID) {
     state.notifyingSessionIds.add(sessionID);
   }
@@ -5484,6 +5638,13 @@ function createTodoContinuationHook(ctx, config) {
   async function handleEvent(input) {
     const { event } = input;
     const properties = event.properties ?? {};
+    hygiene.handleEvent({
+      type: event.type,
+      properties: {
+        info: properties.info,
+        sessionID: properties.sessionID
+      }
+    });
     if (event.type === "session.idle" || event.type === "session.status" && properties.status?.type === "idle") {
       const sessionID = properties.sessionID;
       if (!sessionID) {
@@ -5765,6 +5926,8 @@ function createTodoContinuationHook(ctx, config) {
   }
   return {
     tool: { auto_continue: autoContinue },
+    handleToolExecuteAfter: hygiene.handleToolExecuteAfter,
+    handleChatSystemTransform: hygiene.handleChatSystemTransform,
     handleEvent,
     handleChatMessage,
     handleCommandExecuteBefore
@@ -7344,7 +7507,7 @@ var {spawn: spawn5 } = globalThis.Bun;
 // src/tools/ast-grep/constants.ts
 import { existsSync as existsSync6, statSync as statSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname5, join as join9 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 
 // src/tools/ast-grep/downloader.ts
 import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync2, unlinkSync } from "fs";
@@ -7501,7 +7664,7 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname5(cliPkgPath);
+    const cliDir = dirname6(cliPkgPath);
     const sgPath = join9(cliDir, binaryName);
     if (existsSync6(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
@@ -7512,7 +7675,7 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire2(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname5(pkgPath);
+      const pkgDir = dirname6(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join9(pkgDir, astGrepName);
       if (existsSync6(binaryPath) && isValidBinary(binaryPath)) {
@@ -8074,7 +8237,7 @@ import {
 // src/tools/lsp/config.ts
 import { existsSync as existsSync9 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname7, join as join10, resolve as resolve3 } from "path";
+import { dirname as dirname8, join as join10, resolve as resolve3 } from "path";
 import whichSync from "which";
 
 // src/tools/lsp/config-store.ts
@@ -8106,7 +8269,7 @@ function hasUserLspConfig() {
 
 // src/tools/lsp/constants.ts
 import { existsSync as existsSync8, readdirSync, statSync as statSync3 } from "fs";
-import { dirname as dirname6, resolve as resolve2 } from "path";
+import { dirname as dirname7, resolve as resolve2 } from "path";
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
@@ -8126,10 +8289,10 @@ function* walkUpDirectories(start, stop) {
   let dir = resolve2(start);
   try {
     if (!statSync3(dir).isDirectory()) {
-      dir = dirname6(dir);
+      dir = dirname7(dir);
     }
   } catch {
-    dir = dirname6(dir);
+    dir = dirname7(dir);
   }
   let prevDir = "";
   while (dir !== prevDir && dir !== "/") {
@@ -8137,7 +8300,7 @@ function* walkUpDirectories(start, stop) {
     prevDir = dir;
     if (dir === stop)
       break;
-    dir = dirname6(dir);
+    dir = dirname7(dir);
   }
 }
 function NearestRoot(includePatterns, excludePatterns) {
@@ -8683,7 +8846,7 @@ function getServerWorkspace(config, filePath) {
     return;
   }
   if (!config.root) {
-    return dirname7(resolve3(filePath));
+    return dirname8(resolve3(filePath));
   }
   return config.root(filePath);
 }
@@ -8707,7 +8870,7 @@ function findInstalledServer(configs, filePath) {
   let firstNotInstalled = null;
   for (const config of configs) {
     const workspace = getServerWorkspace(config, filePath);
-    const resolvedCommand = resolveServerCommand(config.command, workspace ?? (filePath ? dirname7(resolve3(filePath)) : undefined));
+    const resolvedCommand = resolveServerCommand(config.command, workspace ?? (filePath ? dirname8(resolve3(filePath)) : undefined));
     const server = toResolvedServer(config, resolvedCommand ?? undefined);
     log(`[LSP] Considering server for ${config.extensions.join(", ")}: ${config.id} with command ${config.command.join(" ")}`);
     if (resolvedCommand) {
@@ -8778,12 +8941,14 @@ function resolveServerCommand(command, cwd) {
 // src/tools/lsp/client.ts
 var START_TIMEOUT_MS = 5000;
 var REQUEST_TIMEOUT_MS = 5000;
+var DIAGNOSTICS_TIMEOUT_MS = 15000;
 var OPEN_FILE_DELAY_MS = 250;
 var INITIALIZE_DELAY_MS = 100;
 var DIAGNOSTIC_SETTLE_DELAY_MS = 250;
 var LSP_TIMEOUTS = {
   start: START_TIMEOUT_MS,
   request: REQUEST_TIMEOUT_MS,
+  diagnostics: DIAGNOSTICS_TIMEOUT_MS,
   openFileDelay: OPEN_FILE_DELAY_MS,
   initializeDelay: INITIALIZE_DELAY_MS,
   diagnosticSettleDelay: DIAGNOSTIC_SETTLE_DELAY_MS
@@ -9208,7 +9373,7 @@ stderr: ${stderr}` : ""));
     await new Promise((r) => setTimeout(r, LSP_TIMEOUTS.initializeDelay));
     log("[lsp] LSPClient.initialize: complete", { server: this.server.id });
   }
-  async waitForPublishedDiagnostics(uri, timeoutMs = LSP_TIMEOUTS.request) {
+  async waitForPublishedDiagnostics(uri, timeoutMs = LSP_TIMEOUTS.diagnostics) {
     const cachedDiagnostics = this.diagnosticsStore.get(uri);
     if (cachedDiagnostics) {
       return cachedDiagnostics;
@@ -9288,6 +9453,7 @@ stderr: ${stderr}` : ""));
   async diagnostics(filePath) {
     const absPath = resolve4(filePath);
     const uri = pathToFileURL(absPath).href;
+    const startedAt = Date.now();
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, LSP_TIMEOUTS.diagnosticSettleDelay));
     log("[lsp] diagnostics mode selected", {
@@ -9305,7 +9471,7 @@ stderr: ${stderr}` : ""));
         const result = this.connection ? await withTimeout(this.connection.sendRequest("textDocument/diagnostic", {
           textDocument: { uri },
           previousResultId: this.diagnosticResultIds.get(uri)
-        }), LSP_TIMEOUTS.request, `LSP diagnostics (${this.server.id})`) : undefined;
+        }), LSP_TIMEOUTS.diagnostics, `LSP diagnostics (${this.server.id})`) : undefined;
         const report = result;
         if (report?.kind === "full") {
           if (report.resultId) {
@@ -9334,7 +9500,9 @@ stderr: ${stderr}` : ""));
         });
       }
     }
-    const cachedDiagnostics = await this.waitForPublishedDiagnostics(uri);
+    const elapsed = Date.now() - startedAt;
+    const remainingTimeout = Math.max(LSP_TIMEOUTS.diagnostics - elapsed, 0);
+    const cachedDiagnostics = await this.waitForPublishedDiagnostics(uri, remainingTimeout);
     if (cachedDiagnostics) {
       return { items: cachedDiagnostics };
     }
@@ -9386,13 +9554,13 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname8, extname as extname3, join as join11, resolve as resolve5 } from "path";
+import { dirname as dirname9, extname as extname3, join as join11, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findServerProjectRoot(filePath, server) {
   if (server.root) {
-    return server.root(filePath) ?? dirname8(resolve5(filePath));
+    return server.root(filePath) ?? dirname9(resolve5(filePath));
   }
-  return dirname8(resolve5(filePath));
+  return dirname9(resolve5(filePath));
 }
 function uriToPath(uri) {
   return fileURLToPath2(uri);
@@ -9422,7 +9590,7 @@ async function withLspClient(filePath, fn) {
     throw new Error(formatServerLookupError(result));
   }
   const server = result.server;
-  const root = findServerProjectRoot(absPath, server) ?? dirname8(absPath);
+  const root = findServerProjectRoot(absPath, server) ?? dirname9(absPath);
   log("[lsp] withLspClient: selected server", {
     filePath: absPath,
     extension: ext,
@@ -11618,6 +11786,13 @@ var OhMyOpenCodeLite = async (ctx) => {
       await multiplexerSessionManager.onSessionDeleted(input.event);
       await interviewManager.handleEvent(input);
       await postFileToolNudgeHook.event(input);
+      if (input.event.type === "session.deleted") {
+        const props = input.event.properties;
+        const sessionID = props?.info?.id ?? props?.sessionID;
+        if (sessionID) {
+          sessionAgentMap.delete(sessionID);
+        }
+      }
     },
     "tool.execute.before": async (input, output) => {
       await applyPatchHook["tool.execute.before"](input, output);
@@ -11648,6 +11823,7 @@ var OhMyOpenCodeLite = async (ctx) => {
 ${output.system[0]}` : "");
         }
       }
+      await todoContinuationHook.handleChatSystemTransform(input, output);
       await postFileToolNudgeHook["experimental.chat.system.transform"](input, output);
     },
     "experimental.chat.messages.transform": async (input, output) => {
@@ -11658,6 +11834,7 @@ ${output.system[0]}` : "");
     "tool.execute.after": async (input, output) => {
       await delegateTaskRetryHook["tool.execute.after"](input, output);
       await jsonErrorRecoveryHook["tool.execute.after"](input, output);
+      await todoContinuationHook.handleToolExecuteAfter(input);
       await postFileToolNudgeHook["tool.execute.after"](input, output);
     }
   };

package/dist/tools/lsp/client.d.ts

@@ -2,6 +2,7 @@ import type { Diagnostic, ResolvedServer } from './types';
 export declare const LSP_TIMEOUTS: {
     start: number;
     request: number;
+    diagnostics: number;
     openFileDelay: number;
     initializeDelay: number;
     diagnosticSettleDelay: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "0.9.11",
+  "version": "0.9.12",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -55,27 +55,27 @@
     "release:major": "npm version major && git push --follow-tags && npm publish"
   },
   "dependencies": {
+    "@ast-grep/cli": "^0.42.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
-    "@ast-grep/cli": "^0.40.0",
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "@opencode-ai/plugin": "^1.2.6",
-    "@opencode-ai/sdk": "^1.2.6",
+    "@opencode-ai/plugin": "^1.3.17",
+    "@opencode-ai/sdk": "^1.3.17",
     "jsdom": "^26.1.0",
-    "lru-cache": "^11.2.2",
-    "turndown": "^7.2.0",
-    "vscode-jsonrpc": "^8.2.0",
+    "lru-cache": "^11.3.3",
+    "turndown": "^7.2.4",
+    "vscode-jsonrpc": "^8.2.1",
     "vscode-languageserver-protocol": "^3.17.5",
-    "which": "^6.0.0",
+    "which": "^6.0.1",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.2",
+    "@biomejs/biome": "2.4.11",
     "@types/jsdom": "^21.1.7",
     "@types/node": "^24.6.1",
-    "@types/turndown": "^5.0.5",
+    "@types/turndown": "^5.0.6",
     "@types/which": "^3.0.4",
     "all-contributors-cli": "^6.26.1",
-    "bun-types": "1.3.9",
+    "bun-types": "1.3.12",
     "typescript": "^5.9.3"
   },
   "trustedDependencies": [

package/src/skills/cartography/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cartography
-description: Repository understanding and hierarchical codemap generation
+description: Generate comprehensive hierarchical codemaps for UNFAMILIAR repositories. Expensive operation - only use when explicitly asked for codebase documentation or initial repository mapping
 ---
 
 # Cartography Skill