@zcy2nn/agent-forge 1.1.0 → 1.1.2

package/dist/cli/custom-skills.d.ts

@@ -1,6 +1,6 @@
 /**
  * A custom skill bundled in this repository.
- * Unlike npx-installed skills, these are copied from src/skills/ to the OpenCode skills directory
+ * Built-in skills are read directly from the package at runtime (no file copy needed).
  */
 export interface CustomSkill {
     /** Skill name (folder name) */
@@ -16,14 +16,3 @@ export interface CustomSkill {
  * Registry of custom skills bundled in this repository.
  */
 export declare const CUSTOM_SKILLS: CustomSkill[];
-/**
- * Get the target directory for custom skills installation.
- */
-export declare function getCustomSkillsDir(): string;
-/**
- * Install a custom skill by copying from src/skills/ to the OpenCode skills directory
- * @param skill - The custom skill to install
- * @param projectRoot - Root directory of agent-forge project
- * @returns True if installation succeeded, false otherwise
- */
-export declare function installCustomSkill(skill: CustomSkill): boolean;

package/dist/cli/index.js

@@ -13,14 +13,14 @@ import * as path from "node:path";
 
 // src/cli/config-io.ts
 import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync3,
+  copyFileSync,
+  existsSync as existsSync2,
   readFileSync,
   renameSync,
-  statSync as statSync2,
+  statSync,
   writeFileSync
 } from "node:fs";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { dirname as dirname2, join as join2 } from "node:path";
 
 // src/cli/paths.ts
 import { existsSync, mkdirSync } from "node:fs";
@@ -390,15 +390,6 @@ var DEFAULT_AGENT_MCPS = {
 };
 
 // src/cli/custom-skills.ts
-import {
-  copyFileSync,
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  statSync
-} from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
-import { fileURLToPath } from "node:url";
 var CUSTOM_SKILLS = [
   {
     name: "simplify",
@@ -491,45 +482,6 @@ var CUSTOM_SKILLS = [
     sourcePath: "src/skills/writing-skills"
   }
 ];
-function getCustomSkillsDir() {
-  return join2(getConfigDir(), "skills");
-}
-function copyDirRecursive(src, dest) {
-  if (!existsSync2(dest)) {
-    mkdirSync2(dest, { recursive: true });
-  }
-  const entries = readdirSync(src);
-  for (const entry of entries) {
-    const srcPath = join2(src, entry);
-    const destPath = join2(dest, entry);
-    const stat = statSync(srcPath);
-    if (stat.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      const destDir = dirname2(destPath);
-      if (!existsSync2(destDir)) {
-        mkdirSync2(destDir, { recursive: true });
-      }
-      copyFileSync(srcPath, destPath);
-    }
-  }
-}
-function installCustomSkill(skill) {
-  try {
-    const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
-    const sourcePath = join2(packageRoot, skill.sourcePath);
-    const targetPath = join2(getCustomSkillsDir(), skill.name);
-    if (!existsSync2(sourcePath)) {
-      console.error(`Custom skill source not found: ${sourcePath}`);
-      return false;
-    }
-    copyDirRecursive(sourcePath, targetPath);
-    return true;
-  } catch (error) {
-    console.error(`Failed to install custom skill: ${skill.name}`, error);
-    return false;
-  }
-}
 
 // src/cli/skills.ts
 import { spawnSync } from "node:child_process";
@@ -642,7 +594,7 @@ function generateLiteConfig(installConfig) {
       ...RECOMMENDED_SKILLS.filter((s) => s.allowedAgents.includes("*") || s.allowedAgents.includes(agentName)).map((s) => s.skillName),
       ...CUSTOM_SKILLS.filter((s) => s.allowedAgents.includes("*") || s.allowedAgents.includes(agentName)).map((s) => s.name)
     ];
-    if (agentName === "implementer" && !skills.includes("agent-browser")) {
+    if (installConfig.installSkills && agentName === "implementer" && !skills.includes("agent-browser")) {
       skills.push("agent-browser");
     }
     return {
@@ -696,10 +648,10 @@ function normalizePathForMatch(path) {
   return path.replaceAll("\\", "/");
 }
 function findPackageRoot(startPath) {
-  let currentPath = dirname3(startPath);
+  let currentPath = dirname2(startPath);
   while (true) {
-    const packageJsonPath = join3(currentPath, "package.json");
-    if (existsSync3(packageJsonPath)) {
+    const packageJsonPath = join2(currentPath, "package.json");
+    if (existsSync2(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
         if (packageJson.name === PACKAGE_NAME) {
@@ -707,7 +659,7 @@ function findPackageRoot(startPath) {
         }
       } catch {}
     }
-    const parentPath = dirname3(currentPath);
+    const parentPath = dirname2(currentPath);
     if (parentPath === currentPath) {
       return null;
     }
@@ -722,8 +674,8 @@ function isLocalPackageRootEntry(entry) {
   if (!entry || entry.startsWith("file://")) {
     return false;
   }
-  const packageJsonPath = join3(entry, "package.json");
-  if (!existsSync3(packageJsonPath)) {
+  const packageJsonPath = join2(entry, "package.json");
+  if (!existsSync2(packageJsonPath)) {
     return false;
   }
   try {
@@ -762,9 +714,9 @@ function stripJsonComments(json) {
 }
 function parseConfigFile(path) {
   try {
-    if (!existsSync3(path))
+    if (!existsSync2(path))
       return { config: null };
-    const stat = statSync2(path);
+    const stat = statSync(path);
     if (stat.size === 0)
       return { config: null };
     const content = readFileSync(path, "utf-8");
@@ -793,8 +745,8 @@ function writeConfig(configPath, config) {
   const bakPath = `${configPath}.bak`;
   const content = `${JSON.stringify(config, null, 2)}
 `;
-  if (existsSync3(configPath)) {
-    copyFileSync2(configPath, bakPath);
+  if (existsSync2(configPath)) {
+    copyFileSync(configPath, bakPath);
   }
   writeFileSync(tmpPath, content);
   renameSync(tmpPath, configPath);
@@ -880,8 +832,8 @@ function writeLiteConfig(installConfig, targetPath) {
     const bakPath = `${configPath}.bak`;
     const content = `${JSON.stringify(config, null, 2)}
 `;
-    if (existsSync3(configPath)) {
-      copyFileSync2(configPath, bakPath);
+    if (existsSync2(configPath)) {
+      copyFileSync(configPath, bakPath);
     }
     writeFileSync(tmpPath, content);
     renameSync(tmpPath, configPath);
@@ -1256,11 +1208,12 @@ Options:
 }
 
 // src/cli/install.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join6 } from "node:path";
 import { createInterface } from "node:readline/promises";
 // src/cli/system.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { statSync as statSync4 } from "node:fs";
+import { statSync as statSync3 } from "node:fs";
 
 // src/utils/compat.ts
 import { spawn as nodeSpawn } from "node:child_process";
@@ -1381,7 +1334,7 @@ function resolveOpenCodePath() {
     if (opencodePath === "opencode")
       continue;
     try {
-      const stat = statSync4(opencodePath);
+      const stat = statSync3(opencodePath);
       if (stat.isFile()) {
         cachedOpenCodePath = opencodePath;
         return opencodePath;
@@ -1433,6 +1386,97 @@ function getOpenCodePath() {
   const path2 = resolveOpenCodePath();
   return path2 === "opencode" ? null : path2;
 }
+// src/cli/skill-sync.ts
+import {
+  cpSync,
+  existsSync as existsSync5,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readlinkSync,
+  rmSync,
+  symlinkSync
+} from "node:fs";
+import { join as join5 } from "node:path";
+
+// src/utils/package-root.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+var _cachedPackageRoot;
+function resolvePackageRoot() {
+  if (_cachedPackageRoot)
+    return _cachedPackageRoot;
+  const distDir = import.meta.dirname;
+  if (!distDir) {
+    throw new Error("import.meta.dirname is not available");
+  }
+  const npmRoot = join4(distDir, "..", "..");
+  if (existsSync4(join4(npmRoot, "src", "skills"))) {
+    _cachedPackageRoot = npmRoot;
+    return npmRoot;
+  }
+  const localRoot = join4(distDir, "..");
+  if (existsSync4(join4(localRoot, "src", "skills"))) {
+    _cachedPackageRoot = localRoot;
+    return localRoot;
+  }
+  _cachedPackageRoot = npmRoot;
+  return npmRoot;
+}
+
+// src/cli/skill-sync.ts
+function syncBuiltinSkills(packageRoot, skillsDirOverride) {
+  const resolvedPackageRoot = packageRoot ?? resolvePackageRoot();
+  const skillsDir = skillsDirOverride ?? join5(getConfigDir(), "skills");
+  mkdirSync2(skillsDir, { recursive: true });
+  let installed = 0;
+  let skipped = 0;
+  let unchanged = 0;
+  let copied = 0;
+  for (const skill of CUSTOM_SKILLS) {
+    const sourcePath = join5(resolvedPackageRoot, skill.sourcePath);
+    const linkPath = join5(skillsDir, skill.name);
+    if (!existsSync5(sourcePath)) {
+      skipped++;
+      continue;
+    }
+    try {
+      if (lstatSync(linkPath).isSymbolicLink()) {
+        const currentTarget = getSymlinkTarget(linkPath);
+        if (currentTarget === sourcePath) {
+          unchanged++;
+          continue;
+        }
+        rmSync(linkPath, { recursive: true, force: true });
+      } else if (existsSync5(linkPath)) {
+        rmSync(linkPath, { recursive: true, force: true });
+      }
+    } catch {
+      try {
+        rmSync(linkPath, { recursive: true, force: true });
+      } catch {}
+    }
+    try {
+      symlinkSync(sourcePath, linkPath, "junction");
+      installed++;
+    } catch {
+      try {
+        cpSync(sourcePath, linkPath, { recursive: true, force: true });
+        copied++;
+      } catch {
+        skipped++;
+      }
+    }
+  }
+  return { installed, skipped, unchanged, copied };
+}
+function getSymlinkTarget(linkPath) {
+  try {
+    return readlinkSync(linkPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
 // src/cli/install.ts
 var GREEN = "\x1B[32m";
 var BLUE = "\x1B[34m";
@@ -1482,6 +1526,9 @@ async function confirm(message, defaultYes = true) {
     rl.close();
   }
 }
+function installBuiltinSkills() {
+  return syncBuiltinSkills();
+}
 async function askToStarRepo(config) {
   if (!config.promptForStar || config.dryRun || !process.stdin.isTTY)
     return;
@@ -1529,11 +1576,9 @@ async function runInstall(config) {
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
   printHeader(isUpdate);
-  let totalSteps = 6;
+  let totalSteps = 7;
   if (config.installSkills)
     totalSteps += 1;
-  if (config.installCustomSkills)
-    totalSteps += 1;
   let step = 1;
   printStep(step++, totalSteps, "Checking OpenCode installation...");
   if (config.dryRun) {
@@ -1587,7 +1632,7 @@ ${JSON.stringify(liteConfig, null, 2)}
 `);
   } else {
     const configPath2 = getExistingLiteConfigPath();
-    const configExists = existsSync5(configPath2);
+    const configExists = existsSync6(configPath2);
     if (configExists && !config.reset) {
       printInfo(`Configuration already exists at ${configPath2}. Use --reset to overwrite.`);
     } else {
@@ -1596,6 +1641,24 @@ ${JSON.stringify(liteConfig, null, 2)}
         return 1;
     }
   }
+  printStep(step++, totalSteps, "Installing built-in skills...");
+  if (config.dryRun) {
+    printInfo("Dry run mode - would install built-in skills:");
+    for (const skill of CUSTOM_SKILLS) {
+      printInfo(`  - ${skill.name}`);
+    }
+  } else {
+    const result = installBuiltinSkills();
+    if (result.installed > 0) {
+      printSuccess(`${result.installed} built-in skill(s) symlinked to ${join6(getConfigDir(), "skills")}`);
+    }
+    if (result.copied > 0) {
+      printInfo(`${result.copied} skill(s) copied (symlink unavailable — auto-update will NOT sync these)`);
+    }
+    if (result.skipped > 0) {
+      printInfo(`${result.skipped} skill(s) skipped`);
+    }
+  }
   if (config.installSkills) {
     printStep(step++, totalSteps, "Installing recommended skills...");
     if (config.dryRun) {
@@ -1616,28 +1679,8 @@ ${JSON.stringify(liteConfig, null, 2)}
       }
       printSuccess(`${skillsInstalled}/${RECOMMENDED_SKILLS.length} skills processed`);
     }
-  }
-  if (config.installCustomSkills) {
-    printStep(step++, totalSteps, "Installing custom skills...");
-    if (config.dryRun) {
-      printInfo("Dry run mode - would install custom skills:");
-      for (const skill of CUSTOM_SKILLS) {
-        printInfo(`  - ${skill.name}`);
-      }
-    } else {
-      let customSkillsInstalled = 0;
-      for (const skill of CUSTOM_SKILLS) {
-        printInfo(`Installing ${skill.name}...`);
-        if (installCustomSkill(skill)) {
-          printSuccess(`Installed: ${skill.name}`);
-          customSkillsInstalled++;
-        } else {
-          printInfo(`Skipped: ${skill.name} (already installed)`);
-        }
-      }
-      const totalCustom = CUSTOM_SKILLS.length;
-      printSuccess(`${customSkillsInstalled}/${totalCustom} custom skills processed`);
-    }
+  } else {
+    printInfo("Recommended skills (e.g. agent-browser) not installed. Use --skills=yes to install them.");
   }
   const statusMsg = isUpdate ? "Configuration updated!" : "Installation complete!";
   console.log(`${SYMBOLS.star} ${BOLD}${GREEN}${statusMsg}${RESET}`);
@@ -1674,7 +1717,6 @@ async function install(args) {
   const config = {
     hasTmux: false,
     installSkills: args.skills === "yes",
-    installCustomSkills: args.skills === "yes",
     preset: args.preset,
     promptForStar: args.tui,
     dryRun: args.dryRun,
@@ -1696,7 +1738,7 @@ function getGeneratedPresetNames2() {
 function parseArgs(args) {
   const result = {
     tui: true,
-    skills: "yes"
+    skills: "no"
   };
   for (const arg of args) {
     if (arg === "--no-tui") {
@@ -1730,7 +1772,7 @@ Usage:
   bunx @zcy2nn/agent-forge doctor [OPTIONS]
 
 Options:
-  --skills=yes|no        Install recommended and bundled skills (default: yes)
+  --skills=yes|no        Install recommended skills like agent-browser (default: no)
   --preset=<name>        Active generated config preset (default: openai)
   --no-tui               Non-interactive mode
   --dry-run              Simulate install without writing files

package/dist/cli/skill-sync.d.ts

@@ -0,0 +1,23 @@
+export interface SkillSyncResult {
+    installed: number;
+    skipped: number;
+    /** Skills that were already correctly symlinked (no change needed) */
+    unchanged: number;
+    /** Skills installed via file copy (symlink unavailable) */
+    copied: number;
+}
+/**
+ * Ensure all built-in skills are symlinked into OpenCode's skills directory.
+ *
+ * - If a symlink already points to the correct source → skip (unchanged).
+ * - If a directory or stale symlink exists → replace with fresh symlink.
+ * - If symlink creation fails (e.g. Windows without junction support) →
+ *   fall back to file copy.
+ * - If the source path doesn't exist in the package → skip.
+ *
+ * @param packageRoot - Absolute path to the agent-forge package root
+ *   (the directory containing `src/skills/`). Defaults to auto-detected via resolvePackageRoot().
+ * @param skillsDirOverride - Override for the target skills directory
+ *   (useful in tests). Defaults to `<configDir>/skills`.
+ */
+export declare function syncBuiltinSkills(packageRoot?: string, skillsDirOverride?: string): SkillSyncResult;

package/dist/cli/types.d.ts

@@ -15,7 +15,6 @@ export interface OpenCodeConfig {
 export interface InstallConfig {
     hasTmux: boolean;
     installSkills: boolean;
-    installCustomSkills: boolean;
     preset?: string;
     promptForStar?: boolean;
     dryRun?: boolean;

package/dist/hooks/filter-available-skills/index.d.ts

@@ -1,7 +1,8 @@
 /**
- * Filter available_skills block based on the current agent's permission.skill rules.
- * OpenCode core injects `<available_skills>` globally, so this hook rewrites that
- * block before the prompt is sent.
+ * Filter and inject available_skills block based on the current agent's permission.skill rules.
+ * OpenCode core injects `<available_skills>` from installed skills, so this hook rewrites that
+ * block before the prompt is sent. Built-in skills from the package are also injected so they
+ * are always visible even without being copied to the OpenCode skills directory.
  */
 import type { PluginInput } from '@opencode-ai/plugin';
 import { type PluginConfig } from '../../config';
@@ -19,6 +20,14 @@ interface MessageWithParts {
     parts: MessagePart[];
 }
 type SkillRule = 'allow' | 'ask' | 'deny';
+interface SkillEntry {
+    name: string;
+    block: string;
+}
+/**
+ * Merge installed skill entries with built-in entries (dedup by name, installed takes precedence).
+ */
+declare function mergeWithBuiltinSkills(installedEntries: SkillEntry[]): SkillEntry[];
 declare function filterAvailableSkillsText(text: string, permissionRules: Record<string, SkillRule>): string;
 /**
  * Creates the experimental.chat.messages.transform hook for filtering available skills.
@@ -29,4 +38,4 @@ export declare function createFilterAvailableSkillsHook(_ctx: PluginInput, confi
         messages: MessageWithParts[];
     }) => Promise<void>;
 };
-export { filterAvailableSkillsText };
+export { filterAvailableSkillsText, mergeWithBuiltinSkills };

package/dist/index.js

@@ -30,8 +30,175 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/cli/custom-skills.ts
+var CUSTOM_SKILLS;
+var init_custom_skills = __esm(() => {
+  CUSTOM_SKILLS = [
+    {
+      name: "simplify",
+      description: "Code simplification and readability-focused refactoring",
+      allowedAgents: ["reviewer"],
+      sourcePath: "src/skills/simplify"
+    },
+    {
+      name: "codemap",
+      description: "Repository understanding and hierarchical codemap generation",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/codemap"
+    },
+    {
+      name: "brainstorming",
+      description: "Turn ideas into designs through collaborative dialogue before implementation",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/brainstorming"
+    },
+    {
+      name: "writing-plans",
+      description: "Create comprehensive implementation plans from specs before touching code",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/writing-plans"
+    },
+    {
+      name: "executing-plans",
+      description: "Execute written implementation plans with review checkpoints",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/executing-plans"
+    },
+    {
+      name: "subagent-driven-development",
+      description: "Execute plans by dispatching fresh subagent per task with two-stage review",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/subagent-driven-development"
+    },
+    {
+      name: "dispatching-parallel-agents",
+      description: "Dispatch parallel agents for independent tasks without shared state",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/dispatching-parallel-agents"
+    },
+    {
+      name: "using-git-worktrees",
+      description: "Create isolated git worktrees before executing implementation plans",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/using-git-worktrees"
+    },
+    {
+      name: "finishing-a-development-branch",
+      description: "Guide completion of development work with structured merge/PR options",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/finishing-a-development-branch"
+    },
+    {
+      name: "requesting-code-review",
+      description: "Dispatch code reviewer subagent to catch issues before merging",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/requesting-code-review"
+    },
+    {
+      name: "test-driven-development",
+      description: "Write failing tests first, then minimal code to pass, before any implementation",
+      allowedAgents: ["implementer"],
+      sourcePath: "src/skills/test-driven-development"
+    },
+    {
+      name: "verification-before-completion",
+      description: "Run verification commands and confirm output before claiming work is complete",
+      allowedAgents: ["implementer"],
+      sourcePath: "src/skills/verification-before-completion"
+    },
+    {
+      name: "systematic-debugging",
+      description: "Find root cause before attempting fixes for any bug or test failure",
+      allowedAgents: ["reviewer"],
+      sourcePath: "src/skills/systematic-debugging"
+    },
+    {
+      name: "receiving-code-review",
+      description: "Evaluate code review feedback with technical rigor before implementing suggestions",
+      allowedAgents: ["reviewer"],
+      sourcePath: "src/skills/receiving-code-review"
+    },
+    {
+      name: "writing-skills",
+      description: "Create and edit skills using TDD methodology for process documentation",
+      allowedAgents: ["orchestrator"],
+      sourcePath: "src/skills/writing-skills"
+    }
+  ];
+});
+
+// src/cli/paths.ts
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function getDefaultOpenCodeConfigDir() {
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
+  return join(userConfigDir, "opencode");
+}
+function getCustomOpenCodeConfigDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  return configDir || undefined;
+}
+function getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
+function getConfigSearchDirs() {
+  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
+  return dirs.filter((dir, index) => {
+    return Boolean(dir) && dirs.indexOf(dir) === index;
+  });
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getDefaultOpenCodeConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+var init_paths = () => {};
+
+// src/utils/package-root.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join13 } from "node:path";
+function resolvePackageRoot() {
+  if (_cachedPackageRoot)
+    return _cachedPackageRoot;
+  const distDir = import.meta.dirname;
+  if (!distDir) {
+    throw new Error("import.meta.dirname is not available");
+  }
+  const npmRoot = join13(distDir, "..", "..");
+  if (existsSync10(join13(npmRoot, "src", "skills"))) {
+    _cachedPackageRoot = npmRoot;
+    return npmRoot;
+  }
+  const localRoot = join13(distDir, "..");
+  if (existsSync10(join13(localRoot, "src", "skills"))) {
+    _cachedPackageRoot = localRoot;
+    return localRoot;
+  }
+  _cachedPackageRoot = npmRoot;
+  return npmRoot;
+}
+var _cachedPackageRoot;
+var init_package_root = () => {};
+
 // node_modules/@mozilla/readability/Readability.js
 var require_Readability = __commonJS((exports, module) => {
   function Readability(doc, options) {
@@ -18185,136 +18352,81 @@ var require_turndown_cjs = __commonJS((exports, module) => {
   module.exports = TurndownService;
 });
 
-// src/cli/custom-skills.ts
-import { dirname as dirname2, join as join2 } from "node:path";
-
-// src/cli/paths.ts
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-function getDefaultOpenCodeConfigDir() {
-  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
-  return join(userConfigDir, "opencode");
-}
-function getCustomOpenCodeConfigDir() {
-  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  return configDir || undefined;
-}
-function getConfigDir() {
-  const customConfigDir = getCustomOpenCodeConfigDir();
-  if (customConfigDir) {
-    return customConfigDir;
+// src/cli/skill-sync.ts
+var exports_skill_sync = {};
+__export(exports_skill_sync, {
+  syncBuiltinSkills: () => syncBuiltinSkills
+});
+import {
+  cpSync,
+  existsSync as existsSync13,
+  lstatSync,
+  mkdirSync as mkdirSync7,
+  readlinkSync,
+  rmSync as rmSync2,
+  symlinkSync
+} from "node:fs";
+import { join as join15 } from "node:path";
+function syncBuiltinSkills(packageRoot, skillsDirOverride) {
+  const resolvedPackageRoot = packageRoot ?? resolvePackageRoot();
+  const skillsDir = skillsDirOverride ?? join15(getConfigDir(), "skills");
+  mkdirSync7(skillsDir, { recursive: true });
+  let installed = 0;
+  let skipped = 0;
+  let unchanged = 0;
+  let copied = 0;
+  for (const skill of CUSTOM_SKILLS) {
+    const sourcePath = join15(resolvedPackageRoot, skill.sourcePath);
+    const linkPath = join15(skillsDir, skill.name);
+    if (!existsSync13(sourcePath)) {
+      skipped++;
+      continue;
+    }
+    try {
+      if (lstatSync(linkPath).isSymbolicLink()) {
+        const currentTarget = getSymlinkTarget(linkPath);
+        if (currentTarget === sourcePath) {
+          unchanged++;
+          continue;
+        }
+        rmSync2(linkPath, { recursive: true, force: true });
+      } else if (existsSync13(linkPath)) {
+        rmSync2(linkPath, { recursive: true, force: true });
+      }
+    } catch {
+      try {
+        rmSync2(linkPath, { recursive: true, force: true });
+      } catch {}
+    }
+    try {
+      symlinkSync(sourcePath, linkPath, "junction");
+      installed++;
+    } catch {
+      try {
+        cpSync(sourcePath, linkPath, { recursive: true, force: true });
+        copied++;
+      } catch {
+        skipped++;
+      }
+    }
   }
-  return getDefaultOpenCodeConfigDir();
-}
-function getConfigSearchDirs() {
-  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
-  return dirs.filter((dir, index) => {
-    return Boolean(dir) && dirs.indexOf(dir) === index;
-  });
+  return { installed, skipped, unchanged, copied };
 }
-function getOpenCodeConfigPaths() {
-  const configDir = getDefaultOpenCodeConfigDir();
-  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
-}
-
-// src/cli/custom-skills.ts
-var CUSTOM_SKILLS = [
-  {
-    name: "simplify",
-    description: "Code simplification and readability-focused refactoring",
-    allowedAgents: ["reviewer"],
-    sourcePath: "src/skills/simplify"
-  },
-  {
-    name: "codemap",
-    description: "Repository understanding and hierarchical codemap generation",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/codemap"
-  },
-  {
-    name: "brainstorming",
-    description: "Turn ideas into designs through collaborative dialogue before implementation",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/brainstorming"
-  },
-  {
-    name: "writing-plans",
-    description: "Create comprehensive implementation plans from specs before touching code",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/writing-plans"
-  },
-  {
-    name: "executing-plans",
-    description: "Execute written implementation plans with review checkpoints",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/executing-plans"
-  },
-  {
-    name: "subagent-driven-development",
-    description: "Execute plans by dispatching fresh subagent per task with two-stage review",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/subagent-driven-development"
-  },
-  {
-    name: "dispatching-parallel-agents",
-    description: "Dispatch parallel agents for independent tasks without shared state",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/dispatching-parallel-agents"
-  },
-  {
-    name: "using-git-worktrees",
-    description: "Create isolated git worktrees before executing implementation plans",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/using-git-worktrees"
-  },
-  {
-    name: "finishing-a-development-branch",
-    description: "Guide completion of development work with structured merge/PR options",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/finishing-a-development-branch"
-  },
-  {
-    name: "requesting-code-review",
-    description: "Dispatch code reviewer subagent to catch issues before merging",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/requesting-code-review"
-  },
-  {
-    name: "test-driven-development",
-    description: "Write failing tests first, then minimal code to pass, before any implementation",
-    allowedAgents: ["implementer"],
-    sourcePath: "src/skills/test-driven-development"
-  },
-  {
-    name: "verification-before-completion",
-    description: "Run verification commands and confirm output before claiming work is complete",
-    allowedAgents: ["implementer"],
-    sourcePath: "src/skills/verification-before-completion"
-  },
-  {
-    name: "systematic-debugging",
-    description: "Find root cause before attempting fixes for any bug or test failure",
-    allowedAgents: ["reviewer"],
-    sourcePath: "src/skills/systematic-debugging"
-  },
-  {
-    name: "receiving-code-review",
-    description: "Evaluate code review feedback with technical rigor before implementing suggestions",
-    allowedAgents: ["reviewer"],
-    sourcePath: "src/skills/receiving-code-review"
-  },
-  {
-    name: "writing-skills",
-    description: "Create and edit skills using TDD methodology for process documentation",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/writing-skills"
+function getSymlinkTarget(linkPath) {
+  try {
+    return readlinkSync(linkPath, "utf-8");
+  } catch {
+    return "";
   }
-];
-function getCustomSkillsDir() {
-  return join2(getConfigDir(), "skills");
 }
+var init_skill_sync = __esm(() => {
+  init_package_root();
+  init_custom_skills();
+  init_paths();
+});
 
 // src/cli/skills.ts
+init_custom_skills();
 var RECOMMENDED_SKILLS = [
   {
     name: "agent-browser",
@@ -18474,6 +18586,9 @@ var CouncilConfigSchema = z.object({
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+// src/cli/config-io.ts
+init_paths();
+
 // src/config/agent-mcps.ts
 var DEFAULT_AGENT_MCPS = {
   orchestrator: ["*", "!context7"],
@@ -18506,6 +18621,9 @@ function getAgentMcpList(agentName, config) {
   return defaultMcps ?? [];
 }
 
+// src/cli/providers.ts
+init_custom_skills();
+
 // src/cli/config-io.ts
 function stripJsonComments(json) {
   const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
@@ -18513,6 +18631,9 @@ function stripJsonComments(json) {
   return json.replace(commentPattern, (match, commentGroup) => commentGroup ? "" : match).replace(trailingCommaPattern, (match, comma, closing) => comma ? closing : match);
 }
 
+// src/config/loader.ts
+init_paths();
+
 // src/config/schema.ts
 import { z as z2 } from "zod";
 var ProviderModelIdSchema = z2.string().regex(/^[^/\s]+\/[^\s]+$/, "Expected provider/model format (provider/.../model)");
@@ -21837,6 +21958,10 @@ async function crossWrite(path6, data) {
 // src/hooks/auto-update-checker/cache.ts
 import * as fs5 from "node:fs";
 import * as path8 from "node:path";
+
+// src/cli/config-manager.ts
+init_paths();
+
 // src/hooks/auto-update-checker/checker.ts
 import * as fs4 from "node:fs";
 import * as path7 from "node:path";
@@ -22808,8 +22933,22 @@ ${buildRetryGuidance(detected)}`;
   };
 }
 // src/hooks/filter-available-skills/index.ts
+init_custom_skills();
 var AVAILABLE_SKILLS_BLOCK_REGEX = /<available_skills>\s*([\s\S]*?)\s*<\/available_skills>/g;
 var SKILL_NAME_REGEX = /<name>([^<]+)<\/name>/;
+function builtinSkillBlock(name, description) {
+  return `<skill>
+  <name>${name}</name>
+  <description>${description}</description>
+  <location>builtin</location>
+</skill>`;
+}
+function getBuiltinSkillEntries() {
+  return CUSTOM_SKILLS.map((skill) => ({
+    name: skill.name,
+    block: builtinSkillBlock(skill.name, skill.description)
+  }));
+}
 function getCurrentAgent(messages) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const message = messages[index];
@@ -22842,9 +22981,21 @@ function isSkillAllowed(skillName, permissionRules) {
   }
   return permissionRules["*"] === "allow";
 }
+function mergeWithBuiltinSkills(installedEntries) {
+  const builtinEntries = getBuiltinSkillEntries();
+  const installedNames = new Set(installedEntries.map((e) => e.name));
+  for (const entry of builtinEntries) {
+    if (!installedNames.has(entry.name)) {
+      installedEntries.push(entry);
+    }
+  }
+  return installedEntries;
+}
 function filterAvailableSkillsText(text, permissionRules) {
   return text.replace(AVAILABLE_SKILLS_BLOCK_REGEX, (_fullMatch, blockContent) => {
-    const allowedEntries = extractSkillEntries(blockContent).filter((entry) => isSkillAllowed(entry.name, permissionRules));
+    let allEntries = extractSkillEntries(blockContent);
+    allEntries = mergeWithBuiltinSkills(allEntries);
+    const allowedEntries = allEntries.filter((entry) => isSkillAllowed(entry.name, permissionRules));
     if (allowedEntries.length === 0) {
       return `<available_skills>
 No skills available.
@@ -22856,6 +23007,22 @@ ${allowedEntries.map((entry) => entry.block).join(`
 </available_skills>`;
   });
 }
+function injectBuiltinSkillsIfMissing(text, permissionRules) {
+  if (text.includes("<available_skills>")) {
+    return text;
+  }
+  const builtinEntries = getBuiltinSkillEntries();
+  const allowedEntries = builtinEntries.filter((entry) => isSkillAllowed(entry.name, permissionRules));
+  if (allowedEntries.length === 0) {
+    return text;
+  }
+  const block = `<available_skills>
+${allowedEntries.map((entry) => entry.block).join(`
+`)}
+</available_skills>`;
+  return `${text}
+${block}`;
+}
 function createFilterAvailableSkillsHook(_ctx, config) {
   const permissionRulesByAgent = new Map;
   const getPermissionRules = (agentName) => {
@@ -22878,10 +23045,14 @@ function createFilterAvailableSkillsHook(_ctx, config) {
       const permissionRules = getPermissionRules(agentName);
       for (const message of messages) {
         for (const part of message.parts) {
-          if (part.type !== "text" || !part.text || !part.text.includes("<available_skills>")) {
+          if (part.type !== "text" || !part.text) {
             continue;
           }
-          part.text = filterAvailableSkillsText(part.text, permissionRules);
+          if (part.text.includes("<available_skills>")) {
+            part.text = filterAvailableSkillsText(part.text, permissionRules);
+          } else {
+            part.text = injectBuiltinSkillsIfMissing(part.text, permissionRules);
+          }
         }
       }
     }
@@ -23123,7 +23294,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { basename as basename2, extname, join as join8 } from "node:path";
+import { basename as basename2, extname, join as join7 } from "node:path";
 var lastCleanupByDir = new Map;
 var CLEANUP_INTERVAL = 10 * 60 * 1000;
 function isImagePart(p) {
@@ -23171,7 +23342,7 @@ function cleanupAllSessions(saveDir) {
   const dirsToScan = [];
   try {
     for (const entry of readdirSync2(saveDir, { withFileTypes: true })) {
-      const fp = join8(saveDir, entry.name);
+      const fp = join7(saveDir, entry.name);
       if (entry.isDirectory()) {
         dirsToScan.push(fp);
       } else {
@@ -23188,7 +23359,7 @@ function cleanupAllSessions(saveDir) {
       let allRemoved = true;
       for (const f of readdirSync2(dir)) {
         isEmpty = false;
-        const fp = join8(dir, f);
+        const fp = join7(dir, f);
         try {
           if (now - statSync3(fp).mtimeMs > maxAge) {
             unlinkSync2(fp);
@@ -23210,7 +23381,7 @@ function cleanupAllSessions(saveDir) {
 function writeUniqueFile(dir, name, data, log2) {
   const ext = extname(name);
   const base = basename2(name, ext) || name;
-  let candidate = join8(dir, name);
+  let candidate = join7(dir, name);
   if (existsSync5(candidate)) {
     return candidate;
   }
@@ -23223,7 +23394,7 @@ function writeUniqueFile(dir, name, data, log2) {
     } catch (e) {
       if (e instanceof Error && e.code === "EEXIST") {
         counter += 1;
-        candidate = join8(dir, `${base}-${counter}${ext}`);
+        candidate = join7(dir, `${base}-${counter}${ext}`);
         continue;
       }
       log2(`[image-hook] failed to save image: ${e}`);
@@ -23247,13 +23418,13 @@ function processImageAttachments(args) {
       messagesWithImages.push({ msg, imageParts });
     }
   }
-  const saveDir = join8(workDir, ".opencode", "images");
+  const saveDir = join7(workDir, ".opencode", "images");
   if (messagesWithImages.length === 0) {
     if (existsSync5(saveDir))
       cleanupAllSessions(saveDir);
     return;
   }
-  const gitignorePath = join8(workDir, ".opencode", ".gitignore");
+  const gitignorePath = join7(workDir, ".opencode", ".gitignore");
   try {
     mkdirSync3(saveDir, { recursive: true });
     if (!existsSync5(gitignorePath))
@@ -23265,7 +23436,7 @@ function processImageAttachments(args) {
   cleanupAllSessions(saveDir);
   for (const { msg, imageParts } of messagesWithImages) {
     const sessionSubdir = msg.info.sessionID ? sanitizeFilename(msg.info.sessionID) : undefined;
-    const targetDir = sessionSubdir ? join8(saveDir, sessionSubdir) : saveDir;
+    const targetDir = sessionSubdir ? join7(saveDir, sessionSubdir) : saveDir;
     try {
       mkdirSync3(targetDir, { recursive: true });
     } catch (e) {
@@ -29236,13 +29407,13 @@ import { existsSync as existsSync9 } from "node:fs";
 // src/tools/ast-grep/constants.ts
 import { existsSync as existsSync8, statSync as statSync4 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname7, join as join12 } from "node:path";
+import { dirname as dirname6, join as join11 } from "node:path";
 
 // src/tools/ast-grep/downloader.ts
 import { chmodSync, existsSync as existsSync7, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir5 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join10 } from "node:path";
 var REPO = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
 function getAstGrepVersion() {
@@ -29266,18 +29437,18 @@ var PLATFORM_MAP = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join11(homedir5(), "AppData", "Local");
-    return join11(base2, "agent-forge", "bin");
+    const base2 = localAppData || join10(homedir5(), "AppData", "Local");
+    return join10(base2, "agent-forge", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join11(homedir5(), ".cache");
-  return join11(base, "agent-forge", "bin");
+  const base = xdgCache || join10(homedir5(), ".cache");
+  return join10(base, "agent-forge", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join11(getCacheDir2(), getBinaryName());
+  const binaryPath = join10(getCacheDir2(), getBinaryName());
   return existsSync7(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version = DEFAULT_VERSION) {
@@ -29289,7 +29460,7 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName();
-  const binaryPath = join11(cacheDir, binaryName);
+  const binaryPath = join10(cacheDir, binaryName);
   if (existsSync7(binaryPath)) {
     return binaryPath;
   }
@@ -29305,7 +29476,7 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join11(cacheDir, assetName);
+    const archivePath = join10(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await crossWrite(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
@@ -29393,8 +29564,8 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire3(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname7(cliPkgPath);
-    const sgPath = join12(cliDir, binaryName);
+    const cliDir = dirname6(cliPkgPath);
+    const sgPath = join11(cliDir, binaryName);
     if (existsSync8(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
@@ -29404,9 +29575,9 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire3(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname7(pkgPath);
+      const pkgDir = dirname6(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join12(pkgDir, astGrepName);
+      const binaryPath = join11(pkgDir, astGrepName);
       if (existsSync8(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
@@ -30072,18 +30243,15 @@ Usage: /preset <name> to switch.`);
   };
 }
 // src/tools/skill.ts
-import { existsSync as existsSync10, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync5 } from "node:fs";
 import { join as join14 } from "node:path";
 import { tool as tool4 } from "@opencode-ai/plugin/tool";
+init_package_root();
 var z5 = tool4.schema;
 function resolveSkillPath(skillName) {
-  const installedPath = join14(getCustomSkillsDir(), skillName, "SKILL.md");
-  if (existsSync10(installedPath)) {
-    return installedPath;
-  }
-  const packageRoot = join14(import.meta.dirname, "..", "..");
+  const packageRoot = resolvePackageRoot();
   const bundledPath = join14(packageRoot, "src", "skills", skillName, "SKILL.md");
-  if (existsSync10(bundledPath)) {
+  if (existsSync11(bundledPath)) {
     return bundledPath;
   }
   return;
@@ -31739,9 +31907,10 @@ function isInvalidLlmsResult(fetchResult) {
 }
 
 // src/tools/smartfetch/secondary-model.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
 import path17 from "node:path";
+init_paths();
 function parseModelRef(value) {
   if (!value)
     return;
@@ -31768,7 +31937,7 @@ function pickAgentModelRef(value) {
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
     const fullPath = path17.join(baseDir, file);
-    if (existsSync11(fullPath))
+    if (existsSync12(fullPath))
       return fullPath;
   }
   return;
@@ -32610,6 +32779,15 @@ var OhMyOpenCodeLite = async (ctx) => {
     mcps = createBuiltinMcps(config.disabled_mcps, config.websearch);
     webfetch = createWebfetchTool(ctx);
     skillTools = createSkillTool(config);
+    try {
+      const { syncBuiltinSkills: syncBuiltinSkills2 } = await Promise.resolve().then(() => (init_skill_sync(), exports_skill_sync));
+      const syncResult = syncBuiltinSkills2();
+      if (syncResult.installed > 0 || syncResult.skipped > 0) {
+        log("[plugin] skill sync:", syncResult);
+      }
+    } catch (err) {
+      log("[plugin] skill sync failed (non-fatal):", err);
+    }
     multiplexerSessionManager = new MultiplexerSessionManager(ctx, multiplexerConfig);
     autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
       autoUpdate: config.autoUpdate ?? true

package/dist/tui.js

@@ -30,6 +30,20 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/tui.ts

package/dist/utils/package-root.d.ts

@@ -0,0 +1 @@
+export declare function resolvePackageRoot(): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcy2nn/agent-forge",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",