oh-my-opencode-slim 2.0.5 → 2.1.0

package/dist/cli/index.js

@@ -90,8 +90,8 @@ function isPwshAvailable() {
   });
   return result.status === 0;
 }
-function escapePowerShellPath(path2) {
-  return path2.replace(/'/g, "''");
+function escapePowerShellPath(path3) {
+  return path3.replace(/'/g, "''");
 }
 function getWindowsZipExtractor() {
   const buildNumber = getWindowsBuildNumber();
@@ -163,17 +163,17 @@ import * as path from "node:path";
 // src/cli/config-io.ts
 init_compat();
 import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
   readFileSync,
   renameSync,
   rmSync,
-  statSync as statSync2,
+  statSync,
   writeFileSync
 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-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";
@@ -279,10 +279,6 @@ function ensureOpenCodeConfigDir() {
 }
 
 // src/config/constants.ts
-var AGENT_ALIASES = {
-  explore: "explorer",
-  "frontend-ui-ux-engineer": "designer"
-};
 var SUBAGENT_NAMES = [
   "explorer",
   "librarian",
@@ -344,7 +340,7 @@ var CouncilConfigSchema = z.object({
   default_preset: z.string().default("default"),
   councillor_execution_mode: CouncillorExecutionModeSchema.describe('Execution mode for councillors. "serial" runs them one at a time (required for single-model systems). "parallel" runs them concurrently (default, faster for multi-model systems).'),
   councillor_retries: z.number().int().min(0).max(5).default(3).describe("Number of retry attempts for councillors that return empty responses " + "(e.g. due to provider rate limiting). Default: 3 retries."),
-  master: z.unknown().optional().describe("DEPRECATED — ignored. Council agent synthesizes directly.")
+  master: z.unknown().optional().describe("DEPRECATED - ignored. Council agent synthesizes directly.")
 }).transform((data) => {
   const deprecated = [];
   if (data.master !== undefined)
@@ -410,7 +406,13 @@ var AgentOverrideConfigSchema = z2.object({
   options: z2.record(z2.string(), z2.unknown()).optional(),
   displayName: z2.string().min(1).optional()
 }).strict();
-var MultiplexerTypeSchema = z2.enum(["auto", "tmux", "zellij", "none"]);
+var MultiplexerTypeSchema = z2.enum([
+  "auto",
+  "tmux",
+  "zellij",
+  "herdr",
+  "none"
+]);
 var MultiplexerLayoutSchema = z2.enum([
   "main-horizontal",
   "main-vertical",
@@ -479,24 +481,13 @@ var AcpAgentConfigSchema = z2.object({
   permissionMode: AcpAgentPermissionModeSchema.default("ask")
 }).strict();
 var AcpAgentsConfigSchema = z2.record(z2.string(), AcpAgentConfigSchema);
-function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
+function rejectOrchestratorPromptOnOrchestrator(overrides, ctx, pathPrefix) {
   for (const [name, override] of Object.entries(overrides)) {
-    const isBuiltInOrAlias = ALL_AGENT_NAMES.includes(name) || AGENT_ALIASES[name] !== undefined;
-    if (!isBuiltInOrAlias) {
-      continue;
-    }
-    if (override.prompt !== undefined) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: [...pathPrefix, name, "prompt"],
-        message: "prompt is only supported for custom agents"
-      });
-    }
-    if (override.orchestratorPrompt !== undefined) {
+    if (name === "orchestrator" && override.orchestratorPrompt !== undefined) {
       ctx.addIssue({
         code: z2.ZodIssueCode.custom,
         path: [...pathPrefix, name, "orchestratorPrompt"],
-        message: "orchestratorPrompt is only supported for custom agents"
+        message: "orchestratorPrompt is not supported for the orchestrator agent"
       });
     }
   }
@@ -504,6 +495,7 @@ function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
 var PluginConfigSchema = z2.object({
   preset: z2.string().optional(),
   setDefaultAgent: z2.boolean().optional(),
+  compactSidebar: z2.boolean().optional().describe("Use the compact TUI sidebar layout when enabled."),
   autoUpdate: z2.boolean().optional().describe("Disable automatic installation of plugin updates when false. Defaults to true."),
   presets: z2.record(z2.string(), PresetSchema).optional(),
   agents: z2.record(z2.string(), AgentOverrideConfigSchema).optional(),
@@ -522,11 +514,14 @@ var PluginConfigSchema = z2.object({
   acpAgents: AcpAgentsConfigSchema.optional()
 }).superRefine((value, ctx) => {
   if (value.agents) {
-    validateCustomOnlyPromptFields(value.agents, ctx, ["agents"]);
+    rejectOrchestratorPromptOnOrchestrator(value.agents, ctx, ["agents"]);
   }
   if (value.presets) {
     for (const [presetName, preset] of Object.entries(value.presets)) {
-      validateCustomOnlyPromptFields(preset, ctx, ["presets", presetName]);
+      rejectOrchestratorPromptOnOrchestrator(preset, ctx, [
+        "presets",
+        presetName
+      ]);
     }
   }
 });
@@ -543,16 +538,7 @@ var DEFAULT_AGENT_MCPS = {
   councillor: []
 };
 
-// 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";
+// src/cli/custom-skills-registry.ts
 var CUSTOM_SKILLS = [
   {
     name: "simplify",
@@ -590,6 +576,12 @@ var CUSTOM_SKILLS = [
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/oh-my-opencode-slim"
   },
+  {
+    name: "release-smoke-test",
+    description: "Validate packed release candidates and bugfixes before public publish",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/release-smoke-test"
+  },
   {
     name: "worktrees",
     description: "Manage Git worktrees as OMO safe isolated coding lanes for complex/risky/parallel work",
@@ -597,45 +589,6 @@ var CUSTOM_SKILLS = [
     sourcePath: "src/skills/worktrees"
   }
 ];
-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/providers.ts
 var SCHEMA_URL = "https://unpkg.com/oh-my-opencode-slim@latest/oh-my-opencode-slim.schema.json";
@@ -677,12 +630,11 @@ var MODEL_MAPPINGS = {
     fixer: { model: "zai-coding-plan/glm-5", variant: "low" }
   },
   "opencode-go": {
-    orchestrator: { model: "opencode-go/glm-5.1" },
-    oracle: { model: "opencode-go/deepseek-v4-pro", variant: "max" },
-    council: { model: "opencode-go/deepseek-v4-pro", variant: "high" },
-    librarian: { model: "opencode-go/minimax-m2.7" },
-    explorer: { model: "opencode-go/minimax-m2.7" },
-    designer: { model: "opencode-go/kimi-k2.6", variant: "medium" },
+    orchestrator: { model: "opencode-go/glm-5.2" },
+    oracle: { model: "opencode-go/qwen3.7-max", variant: "max" },
+    librarian: { model: "opencode-go/deepseek-v4-flash" },
+    explorer: { model: "opencode-go/deepseek-v4-flash" },
+    designer: { model: "opencode-go/kimi-k2.7-code", variant: "medium" },
     fixer: { model: "opencode-go/deepseek-v4-flash", variant: "high" },
     observer: { model: "opencode-go/kimi-k2.6" }
   }
@@ -788,10 +740,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) {
@@ -799,7 +751,7 @@ function findPackageRoot(startPath) {
         }
       } catch {}
     }
-    const parentPath = dirname3(currentPath);
+    const parentPath = dirname2(currentPath);
     if (parentPath === currentPath) {
       return null;
     }
@@ -810,8 +762,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 {
@@ -883,8 +835,8 @@ function getRequestedPackageTag(packageRoot) {
 }
 function getVersionFromPackageRoot(packageRoot) {
   try {
-    const packageJsonPath = join3(packageRoot, "package.json");
-    if (!existsSync3(packageJsonPath))
+    const packageJsonPath = join2(packageRoot, "package.json");
+    if (!existsSync2(packageJsonPath))
       return;
     const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
     return pkg.version;
@@ -893,13 +845,13 @@ function getVersionFromPackageRoot(packageRoot) {
   }
 }
 function getOpenCodePluginCacheDir(version) {
-  const cacheDir = process.env.XDG_CACHE_HOME?.trim() || join3(homedir2(), ".cache");
+  const cacheDir = process.env.XDG_CACHE_HOME?.trim() || join2(homedir2(), ".cache");
   const suffix = version ? `${PACKAGE_NAME}@${version}` : `${PACKAGE_NAME}@latest`;
-  return join3(cacheDir, "opencode", "packages", suffix);
+  return join2(cacheDir, "opencode", "packages", suffix);
 }
 function writeOpenCodePluginCacheManifest(cacheDir, version = "latest") {
   try {
-    writeFileSync(join3(cacheDir, "package.json"), JSON.stringify({
+    writeFileSync(join2(cacheDir, "package.json"), JSON.stringify({
       name: `${PACKAGE_NAME}-cache`,
       private: true,
       dependencies: {
@@ -916,16 +868,16 @@ function writeOpenCodePluginCacheManifest(cacheDir, version = "latest") {
   }
 }
 function removeOpenCodePluginCacheArtifacts(cacheDir) {
-  rmSync(join3(cacheDir, "node_modules", PACKAGE_NAME), {
+  rmSync(join2(cacheDir, "node_modules", PACKAGE_NAME), {
     recursive: true,
     force: true
   });
-  rmSync(join3(cacheDir, "bun.lock"), { force: true });
-  rmSync(join3(cacheDir, "bun.lockb"), { force: true });
+  rmSync(join2(cacheDir, "bun.lock"), { force: true });
+  rmSync(join2(cacheDir, "bun.lockb"), { force: true });
 }
 function verifyOpenCodePluginCache(cacheDir) {
-  const pluginPackageJsonPath = join3(cacheDir, "node_modules", PACKAGE_NAME, "package.json");
-  if (!existsSync3(pluginPackageJsonPath)) {
+  const pluginPackageJsonPath = join2(cacheDir, "node_modules", PACKAGE_NAME, "package.json");
+  if (!existsSync2(pluginPackageJsonPath)) {
     return {
       success: false,
       configPath: cacheDir,
@@ -965,7 +917,7 @@ async function warmOpenCodePluginCache() {
   const cacheVersion = pinnedVersion ?? requestedTag ?? runningVersion;
   const cacheDir = getOpenCodePluginCacheDir(cacheVersion);
   try {
-    mkdirSync3(cacheDir, { recursive: true });
+    mkdirSync2(cacheDir, { recursive: true });
   } catch (err) {
     return {
       success: false,
@@ -1011,9 +963,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");
@@ -1042,8 +994,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);
@@ -1129,8 +1081,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);
@@ -1288,6 +1240,7 @@ function mergePluginConfigs(base, override) {
     ...base,
     ...override,
     agents: deepMerge(base.agents, override.agents),
+    presets: deepMerge(base.presets, override.presets),
     tmux: deepMerge(base.tmux, override.tmux),
     multiplexer: deepMerge(base.multiplexer, override.multiplexer),
     interview: deepMerge(base.interview, override.interview),
@@ -1513,9 +1466,949 @@ Options:
 // src/cli/install.ts
 import { existsSync as existsSync7 } from "node:fs";
 import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+
+// src/hooks/auto-update-checker/skill-sync.ts
+import * as crypto from "node:crypto";
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync4,
+  lstatSync,
+  mkdirSync as mkdirSync3,
+  readdirSync,
+  readFileSync as readFileSync4,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import * as os from "node:os";
+import * as path2 from "node:path";
+
+// src/utils/logger.ts
+import { appendFile } from "node:fs/promises";
+var RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+var logFile = null;
+var writeChain = Promise.resolve();
+function log(message, data) {
+  const target = logFile;
+  if (!target)
+    return;
+  try {
+    const timestamp = new Date().toISOString();
+    let dataStr = "";
+    if (data !== undefined) {
+      try {
+        dataStr = JSON.stringify(data);
+      } catch {
+        dataStr = "[unserializable]";
+      }
+    }
+    const logEntry = `[${timestamp}] ${message} ${dataStr}
+`;
+    writeChain = writeChain.then(() => appendFile(target, logEntry)).catch(() => {});
+  } catch {}
+}
+
+// src/hooks/auto-update-checker/skill-sync.ts
+var localProcessToken = globalThis.OMO_SKILL_SYNC_PROCESS_TOKEN;
+if (!localProcessToken) {
+  localProcessToken = crypto.randomUUID();
+  globalThis.OMO_SKILL_SYNC_PROCESS_TOKEN = localProcessToken;
+}
+var PROCESS_TOKEN = localProcessToken;
+var ACQUIRED_LOCKS = new Set;
+var LEGACY_MANAGED_SKILL_HASHES = {};
+function validateManifest(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  const d = data;
+  if (d.schemaVersion !== 1)
+    return false;
+  if (typeof d.skills !== "object" || d.skills === null)
+    return false;
+  const allowedStatuses = new Set([
+    "managed",
+    "customized",
+    "deleted",
+    "conflict"
+  ]);
+  const skillsObj = d.skills;
+  for (const key of Object.keys(skillsObj)) {
+    const entry = skillsObj[key];
+    if (typeof entry !== "object" || entry === null)
+      return false;
+    if (typeof entry.status !== "string" || !allowedStatuses.has(entry.status))
+      return false;
+    if (typeof entry.packageVersion !== "string")
+      return false;
+    if (typeof entry.sourceHash !== "string")
+      return false;
+    if (typeof entry.lastManagedHash !== "string")
+      return false;
+    if (typeof entry.lastSeenHash !== "string")
+      return false;
+    if (entry.stagedPath !== undefined && typeof entry.stagedPath !== "string")
+      return false;
+    if (typeof entry.updatedAt !== "string")
+      return false;
+  }
+  return true;
+}
+function copyDirRecursive(src, dest) {
+  const stat = lstatSync(src);
+  if (stat.isSymbolicLink()) {
+    return;
+  }
+  if (stat.isDirectory()) {
+    mkdirSync3(dest, { recursive: true });
+    const entries = readdirSync(src);
+    for (const entry of entries) {
+      copyDirRecursive(path2.join(src, entry), path2.join(dest, entry));
+    }
+  } else if (stat.isFile()) {
+    const destDir = path2.dirname(dest);
+    if (!existsSync4(destDir)) {
+      mkdirSync3(destDir, { recursive: true });
+    }
+    copyFileSync2(src, dest);
+  }
+}
+function computeDirectoryHash(dirPath) {
+  const hash = crypto.createHash("sha256");
+  const entriesToHash = [];
+  function traverse(currentDir) {
+    const entries = readdirSync(currentDir);
+    for (const entry of entries) {
+      const absolutePath = path2.join(currentDir, entry);
+      const stat = lstatSync(absolutePath);
+      const relativePath = path2.relative(dirPath, absolutePath);
+      if (stat.isSymbolicLink()) {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        entriesToHash.push({
+          relativePath,
+          absolutePath,
+          kind: "directory",
+          mode: stat.mode
+        });
+        traverse(absolutePath);
+      } else if (stat.isFile()) {
+        entriesToHash.push({
+          relativePath,
+          absolutePath,
+          kind: "file",
+          mode: stat.mode
+        });
+      }
+    }
+  }
+  traverse(dirPath);
+  entriesToHash.sort((a, b) => {
+    if (a.relativePath < b.relativePath)
+      return -1;
+    if (a.relativePath > b.relativePath)
+      return 1;
+    return 0;
+  });
+  for (const entry of entriesToHash) {
+    hash.update(entry.kind);
+    hash.update("\x00");
+    hash.update(entry.relativePath);
+    hash.update("\x00");
+    hash.update(String(entry.mode & 4095));
+    hash.update("\x00");
+    if (entry.kind === "file") {
+      const content = readFileSync4(entry.absolutePath);
+      hash.update(content);
+    }
+  }
+  return hash.digest("hex");
+}
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var CROSS_HOST_LOCK_EXPIRY_MS = 5 * 60 * 1000;
+function acquireLock(lockDir) {
+  const metadataPath = path2.join(lockDir, "owner.json");
+  const currentHost = os.hostname();
+  const currentPid = process.pid;
+  const writeMetadata = () => {
+    try {
+      const metadata = {
+        pid: currentPid,
+        host: currentHost,
+        time: Date.now(),
+        token: PROCESS_TOKEN
+      };
+      writeFileSync2(metadataPath, JSON.stringify(metadata), "utf-8");
+    } catch {}
+  };
+  try {
+    mkdirSync3(lockDir);
+    writeMetadata();
+    ACQUIRED_LOCKS.add(path2.resolve(lockDir));
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      throw err;
+    }
+  }
+  try {
+    let shouldSteal = false;
+    let ageMs = 0;
+    if (existsSync4(metadataPath)) {
+      try {
+        const content = readFileSync4(metadataPath, "utf-8");
+        const metadata = JSON.parse(content);
+        ageMs = Date.now() - metadata.time;
+        if (metadata.host === currentHost) {
+          if (!isPidRunning(metadata.pid)) {
+            log(`[skill-sync] Lock owner process ${metadata.pid} is not running on this host. Recovery path.`);
+            shouldSteal = true;
+          }
+        } else {
+          if (ageMs > CROSS_HOST_LOCK_EXPIRY_MS) {
+            log(`[skill-sync] Lock owned by different host ${metadata.host} has expired (${Math.round(ageMs / 1000)}s old). Reclaiming lock.`);
+            shouldSteal = true;
+          } else {
+            log(`[skill-sync] Lock is owned by different host ${metadata.host}; failing closed.`);
+          }
+        }
+      } catch {
+        shouldSteal = true;
+      }
+    } else {
+      const stat = lstatSync(lockDir);
+      ageMs = Date.now() - stat.mtimeMs;
+      if (ageMs > 30000) {
+        shouldSteal = true;
+      }
+    }
+    if (!shouldSteal)
+      return false;
+    log(`[skill-sync] Stealing/recovering lock directory.`);
+    rmSync2(lockDir, { recursive: true, force: true });
+    mkdirSync3(lockDir);
+    writeMetadata();
+    ACQUIRED_LOCKS.add(path2.resolve(lockDir));
+    return true;
+  } catch (err) {
+    log(`[skill-sync] Failed to check/recover lock at ${lockDir}:`, err);
+    return false;
+  }
+}
+function releaseLock(lockDir) {
+  const resolvedPath = path2.resolve(lockDir);
+  try {
+    let isOurLock = false;
+    const metadataPath = path2.join(lockDir, "owner.json");
+    if (existsSync4(metadataPath)) {
+      try {
+        const content = readFileSync4(metadataPath, "utf-8");
+        const metadata = JSON.parse(content);
+        if (metadata.host === os.hostname() && metadata.pid === process.pid && metadata.token === PROCESS_TOKEN) {
+          isOurLock = true;
+        } else {
+          isOurLock = false;
+        }
+      } catch (err) {
+        log(`[skill-sync] Lock owner.json is unreadable/corrupt:`, err);
+        isOurLock = false;
+      }
+    } else if (ACQUIRED_LOCKS.has(resolvedPath)) {
+      isOurLock = true;
+    }
+    if (isOurLock) {
+      if (existsSync4(lockDir)) {
+        rmSync2(lockDir, { recursive: true, force: true });
+      }
+    } else if (existsSync4(lockDir)) {
+      log(`[skill-sync] Skipping lock directory removal: lock is not owned by this process/token or owner.json check failed.`);
+    }
+  } catch (err) {
+    log(`[skill-sync] Failed to release lock at ${lockDir}:`, err);
+  } finally {
+    ACQUIRED_LOCKS.delete(resolvedPath);
+  }
+}
+function atomicReplaceDir(sourceDir, destDir) {
+  const parentDir = path2.dirname(destDir);
+  if (!existsSync4(parentDir)) {
+    mkdirSync3(parentDir, { recursive: true });
+  }
+  const uniqueSuffix = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  const stagingDir = path2.join(parentDir, `.staging-${path2.basename(destDir)}-${uniqueSuffix}`);
+  const backupDir = path2.join(parentDir, `.backup-${path2.basename(destDir)}-${uniqueSuffix}`);
+  let backupCreated = false;
+  try {
+    copyDirRecursive(sourceDir, stagingDir);
+    if (existsSync4(destDir)) {
+      renameSync2(destDir, backupDir);
+      backupCreated = true;
+    }
+    renameSync2(stagingDir, destDir);
+    if (backupCreated) {
+      rmSync2(backupDir, { recursive: true, force: true });
+    }
+  } catch (err) {
+    log(`[skill-sync] Error during atomic replace for ${destDir}. Rolling back:`, err);
+    if (backupCreated) {
+      try {
+        if (existsSync4(destDir)) {
+          rmSync2(destDir, { recursive: true, force: true });
+        }
+        renameSync2(backupDir, destDir);
+      } catch (rollbackErr) {
+        log(`[skill-sync] Critical error during rollback for ${destDir}:`, rollbackErr);
+      }
+    }
+    try {
+      if (existsSync4(stagingDir)) {
+        rmSync2(stagingDir, { recursive: true, force: true });
+      }
+    } catch {}
+    throw err;
+  }
+}
+function matchesArtifactPattern(entry, prefix, skillName) {
+  if (!entry.startsWith(prefix))
+    return false;
+  const rest = entry.slice(prefix.length);
+  if (!rest.startsWith(`${skillName}-`))
+    return false;
+  const suffix = rest.slice(skillName.length + 1);
+  const firstPart = suffix.split("-")[0];
+  const timestamp = Number(firstPart);
+  if (Number.isNaN(timestamp) || timestamp <= 0)
+    return false;
+  return true;
+}
+function recoverOrphanArtifacts(destSkillsDir, skillName) {
+  if (!existsSync4(destSkillsDir))
+    return false;
+  let hadArtifacts = false;
+  let entries = [];
+  try {
+    entries = readdirSync(destSkillsDir);
+  } catch {
+    return false;
+  }
+  const backups = [];
+  const stagings = [];
+  for (const entry of entries) {
+    if (matchesArtifactPattern(entry, ".backup-", skillName)) {
+      backups.push(path2.join(destSkillsDir, entry));
+      hadArtifacts = true;
+    } else if (matchesArtifactPattern(entry, ".staging-", skillName)) {
+      stagings.push(path2.join(destSkillsDir, entry));
+      hadArtifacts = true;
+    }
+  }
+  const destPath = path2.join(destSkillsDir, skillName);
+  if (backups.length > 0) {
+    backups.sort();
+    const mostRecentBackup = backups[backups.length - 1];
+    if (!existsSync4(destPath)) {
+      backups.pop();
+      try {
+        renameSync2(mostRecentBackup, destPath);
+        log(`[skill-sync] Recovered backup for ${skillName} back to destination.`);
+      } catch (err) {
+        log(`[skill-sync] Failed to restore backup for ${skillName}:`, err);
+      }
+    }
+    for (const backup of backups) {
+      try {
+        rmSync2(backup, { recursive: true, force: true });
+      } catch (err) {
+        log(`[skill-sync] Failed to clean up backup folder ${backup}:`, err);
+      }
+    }
+  }
+  for (const staging of stagings) {
+    try {
+      rmSync2(staging, { recursive: true, force: true });
+    } catch (err) {
+      log(`[skill-sync] Failed to clean up staging folder ${staging}:`, err);
+    }
+  }
+  return hadArtifacts;
+}
+function removeManagedStagedPath(stagedPath, manifestDir, skillName) {
+  try {
+    const absoluteStagedPath = path2.resolve(stagedPath);
+    const absoluteAllowedRoot = path2.resolve(path2.join(manifestDir, "skill-updates"));
+    const relative2 = path2.relative(absoluteAllowedRoot, absoluteStagedPath);
+    const isUnderRoot = relative2 && !relative2.startsWith("..") && !path2.isAbsolute(relative2);
+    if (isUnderRoot) {
+      if (existsSync4(absoluteStagedPath)) {
+        rmSync2(absoluteStagedPath, { recursive: true, force: true });
+        log(`[skill-sync] Safely cleaned up staged path for ${skillName}: ${absoluteStagedPath}`);
+      }
+    } else {
+      log(`[skill-sync] Refusing to delete staged path for ${skillName}: path ${absoluteStagedPath} is not under managed root ${absoluteAllowedRoot}`);
+    }
+  } catch (err) {
+    log(`[skill-sync] Error while trying to verify and remove staged path for ${skillName} (${stagedPath}):`, err);
+  }
+}
+function syncBundledSkillsFromPackage(packageRoot, options = {}) {
+  const installed = [];
+  const skippedExisting = [];
+  const failed = [];
+  const staged = [];
+  const adopted = [];
+  const customized = [];
+  const sourceSkillsDir = path2.join(packageRoot, "src", "skills");
+  try {
+    const stat = lstatSync(sourceSkillsDir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+      log(`[skill-sync] Source skills directory is not a valid directory: ${sourceSkillsDir}`);
+      return {
+        installed,
+        skippedExisting,
+        failed,
+        staged,
+        adopted,
+        customized
+      };
+    }
+  } catch {
+    log(`[skill-sync] Source skills directory does not exist or is unreadable: ${sourceSkillsDir}`);
+    return {
+      installed,
+      skippedExisting,
+      failed,
+      staged,
+      adopted,
+      customized
+    };
+  }
+  let packageVersion = "unknown";
+  try {
+    const pkgJsonPath = path2.join(packageRoot, "package.json");
+    if (existsSync4(pkgJsonPath)) {
+      const content = readFileSync4(pkgJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.version) {
+        packageVersion = pkg.version;
+      }
+    }
+  } catch (err) {
+    log(`[skill-sync] Failed to read package version from ${packageRoot}:`, err);
+  }
+  const manifestDir = path2.join(getConfigDir(), ".oh-my-opencode-slim");
+  const lockDir = path2.join(manifestDir, "skills.lock");
+  try {
+    mkdirSync3(manifestDir, { recursive: true });
+  } catch (err) {
+    log(`[skill-sync] Failed to create manifest directory: ${manifestDir}`, err);
+  }
+  if (!acquireLock(lockDir)) {
+    log("[skill-sync] Failed to acquire lock for skill synchronization. Skipping.");
+    return {
+      installed,
+      skippedExisting,
+      failed: ["__lock__"],
+      staged,
+      adopted,
+      customized
+    };
+  }
+  try {
+    const manifestPath = path2.join(manifestDir, "skills-manifest.json");
+    let manifest = {
+      schemaVersion: 1,
+      updatedAt: new Date().toISOString(),
+      skills: {}
+    };
+    let isManifestCorrupt = false;
+    if (existsSync4(manifestPath)) {
+      try {
+        const content = readFileSync4(manifestPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (validateManifest(parsed)) {
+          manifest = parsed;
+        } else {
+          throw new Error("Manifest validation failed");
+        }
+      } catch (err) {
+        log("[skill-sync] Manifest is corrupt/unreadable. Failing closed.", err);
+        isManifestCorrupt = true;
+      }
+    }
+    const destSkillsDir = path2.join(getConfigDir(), "skills");
+    try {
+      if (!existsSync4(destSkillsDir)) {
+        mkdirSync3(destSkillsDir, { recursive: true });
+      }
+    } catch (err) {
+      log(`[skill-sync] Failed to create destination skills directory: ${destSkillsDir}`, err);
+    }
+    const skillsToProcess = (options.skills ?? CUSTOM_SKILLS).map((s) => ({
+      name: s.name,
+      sourcePath: s.sourcePath
+    }));
+    for (const skill of skillsToProcess) {
+      try {
+        const sourcePath = path2.join(packageRoot, skill.sourcePath);
+        try {
+          const stat = lstatSync(sourcePath);
+          if (stat.isSymbolicLink() || !stat.isDirectory()) {
+            continue;
+          }
+          const skillMdPath = path2.join(sourcePath, "SKILL.md");
+          const skillMdStat = lstatSync(skillMdPath);
+          if (skillMdStat.isSymbolicLink() || !skillMdStat.isFile()) {
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        const destPath = path2.join(destSkillsDir, skill.name);
+        const hadArtifacts = recoverOrphanArtifacts(destSkillsDir, skill.name);
+        let destExists = false;
+        let destIsDir = false;
+        try {
+          const destStat = lstatSync(destPath);
+          destExists = true;
+          destIsDir = destStat.isDirectory() && !destStat.isSymbolicLink();
+        } catch {}
+        if (destExists && !destIsDir) {
+          log(`[skill-sync] Skill ${skill.name} destination is a file or symlink (conflict). Skipping.`);
+          skippedExisting.push(skill.name);
+          const sourceHash2 = computeDirectoryHash(sourcePath);
+          const entry2 = manifest.skills[skill.name];
+          if (entry2?.stagedPath) {
+            removeManagedStagedPath(entry2.stagedPath, manifestDir, skill.name);
+          }
+          manifest.skills[skill.name] = {
+            status: "conflict",
+            packageVersion,
+            sourceHash: sourceHash2,
+            lastManagedHash: "",
+            lastSeenHash: "",
+            updatedAt: new Date().toISOString()
+          };
+          continue;
+        }
+        const sourceHash = computeDirectoryHash(sourcePath);
+        if (isManifestCorrupt) {
+          if (!destExists) {
+            try {
+              atomicReplaceDir(sourcePath, destPath);
+              installed.push(skill.name);
+              manifest.skills[skill.name] = {
+                status: "managed",
+                packageVersion,
+                sourceHash,
+                lastManagedHash: sourceHash,
+                lastSeenHash: sourceHash,
+                updatedAt: new Date().toISOString()
+              };
+            } catch (err) {
+              log(`[skill-sync] Failed to install missing skill ${skill.name} (corrupt manifest mode):`, err);
+              failed.push(skill.name);
+            }
+          } else {
+            log(`[skill-sync] Skipping existing skill ${skill.name} because manifest is corrupt.`);
+            skippedExisting.push(skill.name);
+            const destHash2 = computeDirectoryHash(destPath);
+            if (destHash2 === sourceHash) {
+              manifest.skills[skill.name] = {
+                status: "managed",
+                packageVersion,
+                sourceHash,
+                lastManagedHash: sourceHash,
+                lastSeenHash: sourceHash,
+                updatedAt: new Date().toISOString()
+              };
+            } else {
+              try {
+                const stagedSkillDir = path2.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                if (existsSync4(stagedSkillDir)) {
+                  rmSync2(stagedSkillDir, { recursive: true, force: true });
+                }
+                mkdirSync3(stagedSkillDir, { recursive: true });
+                copyDirRecursive(sourcePath, stagedSkillDir);
+                manifest.skills[skill.name] = {
+                  status: "customized",
+                  packageVersion,
+                  sourceHash,
+                  lastManagedHash: "",
+                  lastSeenHash: destHash2,
+                  stagedPath: stagedSkillDir,
+                  updatedAt: new Date().toISOString()
+                };
+                staged.push(skill.name);
+                customized.push(skill.name);
+              } catch (err) {
+                log(`[skill-sync] Failed to stage update for customized skill ${skill.name} during recovery:`, err);
+                manifest.skills[skill.name] = {
+                  status: "customized",
+                  packageVersion: "unknown",
+                  sourceHash: "",
+                  lastManagedHash: "",
+                  lastSeenHash: destHash2,
+                  updatedAt: new Date().toISOString()
+                };
+              }
+            }
+          }
+          continue;
+        }
+        const entry = manifest.skills[skill.name];
+        if (!destExists) {
+          if (entry && entry.status === "deleted") {
+            log(`[skill-sync] Skill ${skill.name} was deleted by user. Skipping.`);
+            skippedExisting.push(skill.name);
+            continue;
+          }
+          if (entry && entry.status !== "deleted") {
+            if (hadArtifacts) {
+              log(`[skill-sync] Managed skill ${skill.name} has backup/staging artifacts. Skipping delete, re-installing.`);
+              try {
+                atomicReplaceDir(sourcePath, destPath);
+                installed.push(skill.name);
+                manifest.skills[skill.name] = {
+                  status: "managed",
+                  packageVersion,
+                  sourceHash,
+                  lastManagedHash: sourceHash,
+                  lastSeenHash: sourceHash,
+                  updatedAt: new Date().toISOString()
+                };
+              } catch (err) {
+                log(`[skill-sync] Failed to re-install skill ${skill.name}:`, err);
+                failed.push(skill.name);
+              }
+              continue;
+            } else {
+              if (entry.stagedPath) {
+                removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                delete entry.stagedPath;
+              }
+              const rawEntry = entry;
+              delete rawEntry.stagedVersion;
+              delete rawEntry.stagedHash;
+              entry.status = "deleted";
+              entry.updatedAt = new Date().toISOString();
+              log(`[skill-sync] Skill ${skill.name} was deleted by user (detected now). Skipping.`);
+              skippedExisting.push(skill.name);
+              continue;
+            }
+          }
+          try {
+            atomicReplaceDir(sourcePath, destPath);
+            installed.push(skill.name);
+            manifest.skills[skill.name] = {
+              status: "managed",
+              packageVersion,
+              sourceHash,
+              lastManagedHash: sourceHash,
+              lastSeenHash: sourceHash,
+              updatedAt: new Date().toISOString()
+            };
+            log(`[skill-sync] Successfully installed missing skill: ${skill.name}`);
+          } catch (err) {
+            log(`[skill-sync] Failed to install skill ${skill.name}:`, err);
+            failed.push(skill.name);
+          }
+          continue;
+        }
+        const destHash = computeDirectoryHash(destPath);
+        if (entry) {
+          if (entry.status === "managed") {
+            if (destHash === entry.lastManagedHash) {
+              if (destHash === sourceHash) {
+                entry.packageVersion = packageVersion;
+                entry.sourceHash = sourceHash;
+                entry.lastManagedHash = sourceHash;
+                entry.lastSeenHash = sourceHash;
+                entry.updatedAt = new Date().toISOString();
+                skippedExisting.push(skill.name);
+              } else {
+                try {
+                  atomicReplaceDir(sourcePath, destPath);
+                  installed.push(skill.name);
+                  manifest.skills[skill.name] = {
+                    status: "managed",
+                    packageVersion,
+                    sourceHash,
+                    lastManagedHash: sourceHash,
+                    lastSeenHash: sourceHash,
+                    updatedAt: new Date().toISOString()
+                  };
+                  log(`[skill-sync] Updated managed skill: ${skill.name}`);
+                } catch (err) {
+                  log(`[skill-sync] Failed to update managed skill ${skill.name}:`, err);
+                  failed.push(skill.name);
+                }
+              }
+            } else {
+              if (destHash === sourceHash) {
+                manifest.skills[skill.name] = {
+                  status: "managed",
+                  packageVersion,
+                  sourceHash,
+                  lastManagedHash: sourceHash,
+                  lastSeenHash: sourceHash,
+                  updatedAt: new Date().toISOString()
+                };
+                skippedExisting.push(skill.name);
+              } else {
+                try {
+                  const stagedSkillDir = path2.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                  if (entry.stagedPath && entry.stagedPath !== stagedSkillDir) {
+                    removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                  }
+                  if (existsSync4(stagedSkillDir)) {
+                    rmSync2(stagedSkillDir, { recursive: true, force: true });
+                  }
+                  mkdirSync3(stagedSkillDir, { recursive: true });
+                  copyDirRecursive(sourcePath, stagedSkillDir);
+                  entry.status = "customized";
+                  entry.lastSeenHash = destHash;
+                  entry.stagedPath = stagedSkillDir;
+                  entry.sourceHash = sourceHash;
+                  entry.packageVersion = packageVersion;
+                  entry.updatedAt = new Date().toISOString();
+                  staged.push(skill.name);
+                  customized.push(skill.name);
+                  skippedExisting.push(skill.name);
+                  log(`[skill-sync] Skill ${skill.name} is customized. Staged update at ${stagedSkillDir}`);
+                } catch (err) {
+                  log(`[skill-sync] Failed to stage update for customized skill ${skill.name}:`, err);
+                  failed.push(skill.name);
+                }
+              }
+            }
+          } else if (entry.status === "customized") {
+            if (destHash === sourceHash) {
+              if (entry.stagedPath) {
+                removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+              }
+              entry.status = "managed";
+              entry.lastManagedHash = sourceHash;
+              entry.lastSeenHash = sourceHash;
+              entry.sourceHash = sourceHash;
+              entry.packageVersion = packageVersion;
+              delete entry.stagedPath;
+              entry.updatedAt = new Date().toISOString();
+              adopted.push(skill.name);
+              skippedExisting.push(skill.name);
+              log(`[skill-sync] Customized skill ${skill.name} converged with current version. Adopted back to managed.`);
+            } else {
+              entry.lastSeenHash = destHash;
+              entry.updatedAt = new Date().toISOString();
+              if (destHash !== sourceHash && entry.sourceHash !== sourceHash) {
+                try {
+                  const stagedSkillDir = path2.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                  if (entry.stagedPath && entry.stagedPath !== stagedSkillDir) {
+                    removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                  }
+                  if (existsSync4(stagedSkillDir)) {
+                    rmSync2(stagedSkillDir, { recursive: true, force: true });
+                  }
+                  mkdirSync3(stagedSkillDir, { recursive: true });
+                  copyDirRecursive(sourcePath, stagedSkillDir);
+                  entry.stagedPath = stagedSkillDir;
+                  entry.sourceHash = sourceHash;
+                  entry.packageVersion = packageVersion;
+                  staged.push(skill.name);
+                  customized.push(skill.name);
+                  skippedExisting.push(skill.name);
+                  log(`[skill-sync] Staged new update for customized skill ${skill.name} at ${stagedSkillDir}`);
+                } catch (err) {
+                  log(`[skill-sync] Failed to stage update for customized skill ${skill.name}:`, err);
+                  failed.push(skill.name);
+                }
+              } else {
+                customized.push(skill.name);
+                skippedExisting.push(skill.name);
+              }
+            }
+          } else if (entry.status === "deleted") {
+            if (destHash === sourceHash) {
+              entry.status = "managed";
+              entry.packageVersion = packageVersion;
+              entry.sourceHash = sourceHash;
+              entry.lastManagedHash = sourceHash;
+              entry.lastSeenHash = sourceHash;
+              entry.updatedAt = new Date().toISOString();
+              skippedExisting.push(skill.name);
+              adopted.push(skill.name);
+              log(`[skill-sync] Skill ${skill.name} re-created by user (matching current). Adopted as managed.`);
+            } else {
+              try {
+                const stagedSkillDir = path2.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                if (entry.stagedPath && entry.stagedPath !== stagedSkillDir) {
+                  removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                }
+                if (existsSync4(stagedSkillDir)) {
+                  rmSync2(stagedSkillDir, { recursive: true, force: true });
+                }
+                mkdirSync3(stagedSkillDir, { recursive: true });
+                copyDirRecursive(sourcePath, stagedSkillDir);
+                entry.status = "customized";
+                entry.packageVersion = packageVersion;
+                entry.sourceHash = sourceHash;
+                entry.lastManagedHash = sourceHash;
+                entry.lastSeenHash = destHash;
+                entry.stagedPath = stagedSkillDir;
+                entry.updatedAt = new Date().toISOString();
+                staged.push(skill.name);
+                customized.push(skill.name);
+                skippedExisting.push(skill.name);
+                log(`[skill-sync] Skill ${skill.name} re-created by user (custom). Marked customized and staged.`);
+              } catch (err) {
+                log(`[skill-sync] Failed to stage update for deleted/recreated skill ${skill.name}:`, err);
+                failed.push(skill.name);
+              }
+            }
+          } else if (entry.status === "conflict") {
+            if (destHash === sourceHash) {
+              if (entry.stagedPath) {
+                removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+              }
+              entry.status = "managed";
+              entry.packageVersion = packageVersion;
+              entry.sourceHash = sourceHash;
+              entry.lastManagedHash = sourceHash;
+              entry.lastSeenHash = sourceHash;
+              delete entry.stagedPath;
+              entry.updatedAt = new Date().toISOString();
+              adopted.push(skill.name);
+            } else {
+              try {
+                const stagedSkillDir = path2.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                if (entry.stagedPath && entry.stagedPath !== stagedSkillDir) {
+                  removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                }
+                if (existsSync4(stagedSkillDir)) {
+                  rmSync2(stagedSkillDir, { recursive: true, force: true });
+                }
+                mkdirSync3(stagedSkillDir, { recursive: true });
+                copyDirRecursive(sourcePath, stagedSkillDir);
+                entry.status = "customized";
+                entry.packageVersion = packageVersion;
+                entry.sourceHash = sourceHash;
+                entry.lastManagedHash = sourceHash;
+                entry.lastSeenHash = destHash;
+                entry.stagedPath = stagedSkillDir;
+                entry.updatedAt = new Date().toISOString();
+                staged.push(skill.name);
+                customized.push(skill.name);
+                skippedExisting.push(skill.name);
+                log(`[skill-sync] Conflicted skill ${skill.name} recovered as customized and staged at ${stagedSkillDir}`);
+              } catch (err) {
+                log(`[skill-sync] Failed to stage update for conflicted skill ${skill.name}:`, err);
+                failed.push(skill.name);
+              }
+            }
+          }
+        } else {
+          if (destHash === sourceHash) {
+            manifest.skills[skill.name] = {
+              status: "managed",
+              packageVersion,
+              sourceHash,
+              lastManagedHash: sourceHash,
+              lastSeenHash: sourceHash,
+              updatedAt: new Date().toISOString()
+            };
+            skippedExisting.push(skill.name);
+            adopted.push(skill.name);
+            log(`[skill-sync] Adopted existing matching skill: ${skill.name}`);
+          } else if (LEGACY_MANAGED_SKILL_HASHES[skill.name]?.includes(destHash)) {
+            try {
+              atomicReplaceDir(sourcePath, destPath);
+              installed.push(skill.name);
+              manifest.skills[skill.name] = {
+                status: "managed",
+                packageVersion,
+                sourceHash,
+                lastManagedHash: sourceHash,
+                lastSeenHash: sourceHash,
+                updatedAt: new Date().toISOString()
+              };
+              log(`[skill-sync] Adopted and updated legacy skill: ${skill.name}`);
+            } catch (err) {
+              log(`[skill-sync] Failed to update legacy skill ${skill.name}:`, err);
+              failed.push(skill.name);
+            }
+          } else {
+            try {
+              const stagedSkillDir = path2.join(manifestDir, "skill-updates", packageVersion, skill.name);
+              if (existsSync4(stagedSkillDir)) {
+                rmSync2(stagedSkillDir, { recursive: true, force: true });
+              }
+              mkdirSync3(stagedSkillDir, { recursive: true });
+              copyDirRecursive(sourcePath, stagedSkillDir);
+              manifest.skills[skill.name] = {
+                status: "customized",
+                packageVersion,
+                sourceHash,
+                lastManagedHash: "",
+                lastSeenHash: destHash,
+                stagedPath: stagedSkillDir,
+                updatedAt: new Date().toISOString()
+              };
+              staged.push(skill.name);
+              customized.push(skill.name);
+              skippedExisting.push(skill.name);
+              log(`[skill-sync] Skill ${skill.name} is customized (no manifest entry). Staged update at ${stagedSkillDir}`);
+            } catch (err) {
+              log(`[skill-sync] Failed to stage update for customized skill ${skill.name}:`, err);
+              failed.push(skill.name);
+            }
+          }
+        }
+      } catch (err) {
+        log(`[skill-sync] Failed processing skill ${skill.name}:`, err);
+        failed.push(skill.name);
+      }
+    }
+    let manifestWriteFailed = false;
+    manifest.updatedAt = new Date().toISOString();
+    const tempManifestPath = `${manifestPath}.${Math.random().toString(36).slice(2, 9)}.tmp`;
+    try {
+      writeFileSync2(tempManifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+      renameSync2(tempManifestPath, manifestPath);
+    } catch (err) {
+      log("[skill-sync] Failed to write skills manifest atomically:", err);
+      manifestWriteFailed = true;
+      try {
+        if (existsSync4(tempManifestPath)) {
+          unlinkSync(tempManifestPath);
+        }
+      } catch {}
+    }
+    if (manifestWriteFailed) {
+      failed.push("__manifest__");
+    }
+  } finally {
+    releaseLock(lockDir);
+  }
+  return {
+    installed,
+    skippedExisting,
+    failed,
+    staged,
+    adopted,
+    customized
+  };
+}
 
 // src/cli/background-subagents.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { dirname as dirname4, join as join5 } from "node:path";
 var ENV_NAME = "OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS";
@@ -1604,57 +2497,30 @@ function upsertBackgroundSubagentsBlock(content, block) {
 }
 function writeBackgroundSubagentsBlock(targetPath) {
   const block = getBackgroundSubagentsBlock(targetPath);
-  const content = existsSync5(targetPath) ? readFileSync4(targetPath, "utf8") : "";
+  const content = existsSync5(targetPath) ? readFileSync5(targetPath, "utf8") : "";
   const nextContent = upsertBackgroundSubagentsBlock(content, block);
   mkdirSync4(dirname4(targetPath), { recursive: true });
-  writeFileSync2(targetPath, nextContent);
+  writeFileSync3(targetPath, nextContent);
 }
 
 // src/companion/updater.ts
 init_compat();
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import {
   chmodSync,
   copyFileSync as copyFileSync3,
   existsSync as existsSync6,
   mkdirSync as mkdirSync5,
   mkdtempSync,
-  readFileSync as readFileSync5,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  statSync as statSync4,
-  writeFileSync as writeFileSync3
+  readFileSync as readFileSync6,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync4
 } from "node:fs";
 import { homedir as homedir4, platform, tmpdir } from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
-
-// src/utils/logger.ts
-import { appendFile } from "node:fs/promises";
-var RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-var logFile = null;
-var writeChain = Promise.resolve();
-function log(message, data) {
-  const target = logFile;
-  if (!target)
-    return;
-  try {
-    const timestamp = new Date().toISOString();
-    let dataStr = "";
-    if (data !== undefined) {
-      try {
-        dataStr = JSON.stringify(data);
-      } catch {
-        dataStr = "[unserializable]";
-      }
-    }
-    const logEntry = `[${timestamp}] ${message} ${dataStr}
-`;
-    writeChain = writeChain.then(() => appendFile(target, logEntry)).catch(() => {});
-  } catch {}
-}
-
-// src/companion/updater.ts
 var DOWNLOAD_TIMEOUT_MS = 30000;
 var LOCK_TIMEOUT_MS = 2000;
 var STALE_LOCK_MS = 5 * 60000;
@@ -1692,8 +2558,8 @@ function getCompanionTarget() {
 }
 function getCompanionBinaryPath() {
   const xdg = process.env.XDG_DATA_HOME?.trim();
-  const base = xdg && path2.isAbsolute(xdg) ? xdg : path2.join(homedir4(), ".local", "share");
-  return path2.join(base, "opencode", "storage", "oh-my-opencode-slim", "bin", platform() === "win32" ? "oh-my-opencode-slim-companion.exe" : "oh-my-opencode-slim-companion");
+  const base = xdg && path3.isAbsolute(xdg) ? xdg : path3.join(homedir4(), ".local", "share");
+  return path3.join(base, "opencode", "storage", "oh-my-opencode-slim", "bin", platform() === "win32" ? "oh-my-opencode-slim-companion.exe" : "oh-my-opencode-slim-companion");
 }
 async function ensureCompanionVersion(options) {
   const { config, dryRun = false } = options;
@@ -1790,7 +2656,7 @@ async function installCompanionArchive(finalBinaryPath, target, manifest, downlo
   } finally {
     clearTimeout(timeout);
   }
-  const checksum = createHash("sha256").update(Buffer.from(buffer)).digest("hex");
+  const checksum = createHash2("sha256").update(Buffer.from(buffer)).digest("hex");
   if (checksum !== expectedChecksum) {
     return {
       status: "failed",
@@ -1800,10 +2666,10 @@ async function installCompanionArchive(finalBinaryPath, target, manifest, downlo
   }
   let tempDir = "";
   try {
-    tempDir = mkdtempSync(path2.join(tmpdir(), "companion-install-"));
-    const archivePath = path2.join(tempDir, archiveName);
-    writeFileSync3(archivePath, Buffer.from(buffer));
-    const extractedDir = path2.join(tempDir, "extracted");
+    tempDir = mkdtempSync(path3.join(tmpdir(), "companion-install-"));
+    const archivePath = path3.join(tempDir, archiveName);
+    writeFileSync4(archivePath, Buffer.from(buffer));
+    const extractedDir = path3.join(tempDir, "extracted");
     mkdirSync5(extractedDir, { recursive: true });
     if (isWindows) {
       const { extractZip: extractZip2 } = await Promise.resolve().then(() => (init_zip_extractor(), exports_zip_extractor));
@@ -1821,7 +2687,7 @@ async function installCompanionArchive(finalBinaryPath, target, manifest, downlo
       }
     }
     const binaryName = isWindows ? "oh-my-opencode-slim-companion.exe" : "oh-my-opencode-slim-companion";
-    const extractedBinaryPath = path2.join(extractedDir, binaryName);
+    const extractedBinaryPath = path3.join(extractedDir, binaryName);
     if (!existsSync6(extractedBinaryPath)) {
       return {
         status: "failed",
@@ -1829,14 +2695,14 @@ async function installCompanionArchive(finalBinaryPath, target, manifest, downlo
         error: `Binary ${binaryName} not found in extracted archive`
       };
     }
-    const binDir = path2.dirname(finalBinaryPath);
+    const binDir = path3.dirname(finalBinaryPath);
     mkdirSync5(binDir, { recursive: true });
     const tmpFinalPath = `${finalBinaryPath}.tmp`;
     copyFileSync3(extractedBinaryPath, tmpFinalPath);
     if (!isWindows) {
       chmodSync(tmpFinalPath, 493);
     }
-    renameSync2(tmpFinalPath, finalBinaryPath);
+    renameSync3(tmpFinalPath, finalBinaryPath);
     writeInstallMetadata(finalBinaryPath, {
       version: manifest.version,
       tag: manifest.tag,
@@ -1859,14 +2725,14 @@ async function installCompanionArchive(finalBinaryPath, target, manifest, downlo
   } finally {
     if (tempDir) {
       try {
-        rmSync2(tempDir, { recursive: true, force: true });
+        rmSync3(tempDir, { recursive: true, force: true });
       } catch {}
     }
   }
 }
 function readInstallMetadata(binaryPath) {
   try {
-    const parsed = JSON.parse(readFileSync5(metadataPath(binaryPath), "utf8"));
+    const parsed = JSON.parse(readFileSync6(metadataPath(binaryPath), "utf8"));
     if (parsed?.version && parsed.tag && parsed.target) {
       return parsed;
     }
@@ -1874,7 +2740,7 @@ function readInstallMetadata(binaryPath) {
   return null;
 }
 function writeInstallMetadata(binaryPath, metadata) {
-  writeFileSync3(metadataPath(binaryPath), JSON.stringify(metadata, null, 2));
+  writeFileSync4(metadataPath(binaryPath), JSON.stringify(metadata, null, 2));
 }
 function metadataPath(binaryPath) {
   return `${binaryPath}.json`;
@@ -1883,7 +2749,7 @@ async function withCompanionInstallLock(binaryPath, timeoutMs, staleMs, run) {
   const lock = `${binaryPath}.lock`;
   const deadline = Date.now() + (timeoutMs ?? LOCK_TIMEOUT_MS);
   const staleAfterMs = staleMs ?? STALE_LOCK_MS;
-  mkdirSync5(path2.dirname(binaryPath), { recursive: true });
+  mkdirSync5(path3.dirname(binaryPath), { recursive: true });
   while (Date.now() <= deadline) {
     try {
       mkdirSync5(lock);
@@ -1891,7 +2757,7 @@ async function withCompanionInstallLock(binaryPath, timeoutMs, staleMs, run) {
         return await run();
       } finally {
         try {
-          rmSync2(lock, { recursive: true, force: true });
+          rmSync3(lock, { recursive: true, force: true });
         } catch {}
       }
     } catch (err) {
@@ -1899,9 +2765,9 @@ async function withCompanionInstallLock(binaryPath, timeoutMs, staleMs, run) {
       if (code !== "EEXIST")
         throw err;
       try {
-        const ageMs = Date.now() - statSync4(lock).mtimeMs;
+        const ageMs = Date.now() - statSync3(lock).mtimeMs;
         if (ageMs > staleAfterMs) {
-          rmSync2(lock, { recursive: true, force: true });
+          rmSync3(lock, { recursive: true, force: true });
           log("[companion] removed stale install lock", lock);
           continue;
         }
@@ -1988,7 +2854,7 @@ async function installCompanion(config) {
 // src/cli/system.ts
 init_compat();
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { statSync as statSync5 } from "node:fs";
+import { statSync as statSync4 } from "node:fs";
 var cachedOpenCodePath = null;
 function resolvePathCommand(command) {
   try {
@@ -2061,7 +2927,7 @@ function resolveOpenCodePath() {
     if (opencodePath === "opencode")
       continue;
     try {
-      const stat = statSync5(opencodePath);
+      const stat = statSync4(opencodePath);
       if (stat.isFile()) {
         cachedOpenCodePath = opencodePath;
         return opencodePath;
@@ -2110,8 +2976,8 @@ async function getOpenCodeVersion() {
   return null;
 }
 function getOpenCodePath() {
-  const path3 = resolveOpenCodePath();
-  return path3 === "opencode" ? null : path3;
+  const path4 = resolveOpenCodePath();
+  return path4 === "opencode" ? null : path4;
 }
 // src/cli/install.ts
 var GREEN = "\x1B[32m";
@@ -2194,11 +3060,11 @@ async function checkOpenCodeInstalled() {
     return { ok: false };
   }
   const version = await getOpenCodeVersion();
-  const path3 = getOpenCodePath();
+  const path4 = getOpenCodePath();
   const detectedVersion = version ?? "";
-  const pathInfo = path3 ? ` (${DIM}${path3}${RESET})` : "";
+  const pathInfo = path4 ? ` (${DIM}${path4}${RESET})` : "";
   printSuccess(`OpenCode ${detectedVersion} detected${pathInfo}`);
-  return { ok: true, version: version ?? undefined, path: path3 ?? undefined };
+  return { ok: true, version: version ?? undefined, path: path4 ?? undefined };
 }
 async function configureBackgroundSubagents(config) {
   if (isBackgroundSubagentsEnabled(process.env.OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS)) {
@@ -2260,9 +3126,9 @@ async function shouldInstallCompanion(config) {
   if (config.companion === "no")
     return false;
   if (config.dryRun) {
-    printInfo("Dry run mode - would ask to install the desktop companion (default: yes).");
-    config.companion = "yes";
-    return true;
+    printInfo("Dry run mode - would ask to install the desktop companion (default: no).");
+    config.companion = "no";
+    return false;
   }
   if (!process.stdin.isTTY) {
     printInfo("Skipped desktop companion prompt in non-TTY mode. Use --companion=yes to install it.");
@@ -2271,7 +3137,7 @@ async function shouldInstallCompanion(config) {
   }
   console.log();
   printInfo("The optional desktop companion shows live agent activity.");
-  const shouldInstall = await confirm("Install and enable the desktop companion?", true);
+  const shouldInstall = await confirm("Install and enable the desktop companion?", false);
   config.companion = shouldInstall ? "yes" : "no";
   if (!shouldInstall) {
     printInfo("Desktop companion install skipped.");
@@ -2390,25 +3256,63 @@ ${JSON.stringify(liteConfig, null, 2)}
     }
   }
   if (config.installCustomSkills) {
-    printStep(step++, totalSteps, "Installing custom skills...");
+    printStep(step++, totalSteps, "Synchronizing custom skills...");
     if (config.dryRun) {
-      printInfo("Dry run mode - would install custom skills:");
+      printInfo("Dry run mode - would synchronize 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)`);
+      try {
+        const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+        const result = syncBundledSkillsFromPackage(packageRoot);
+        const categorizedSkipped = new Set([
+          ...result.staged,
+          ...result.adopted,
+          ...result.customized
+        ]);
+        const preservedSkills = result.skippedExisting.filter((skill) => !categorizedSkipped.has(skill));
+        if (result.installed.length > 0) {
+          for (const skill of result.installed) {
+            printSuccess(`Installed/Updated: ${skill}`);
+          }
+        }
+        if (preservedSkills.length > 0) {
+          for (const skill of preservedSkills) {
+            printInfo(`Skipped/Preserved: ${skill}`);
+          }
+        }
+        if (result.failed.length > 0) {
+          for (const skill of result.failed) {
+            if (skill === "__lock__") {
+              printError("Lock acquisition failed");
+            } else if (skill === "__manifest__") {
+              printError("Manifest write failed");
+            } else {
+              printError(`Failed: ${skill}`);
+            }
+          }
+        }
+        if (result.staged.length > 0) {
+          for (const skill of result.staged) {
+            printInfo(`Staged for review: ${skill}`);
+          }
+        }
+        if (result.adopted.length > 0) {
+          for (const skill of result.adopted) {
+            printInfo(`Adopted: ${skill}`);
+          }
+        }
+        if (result.customized.length > 0) {
+          for (const skill of result.customized) {
+            printInfo(`Customized: ${skill}`);
+          }
         }
+        const realFailed = result.failed.filter((skill) => skill !== "__lock__" && skill !== "__manifest__");
+        printSuccess(`Skill synchronization complete: ${result.installed.length} installed/updated, ${preservedSkills.length} skipped/preserved, ${result.staged.length} staged, ${result.adopted.length} adopted, ${result.customized.length} customized, ${realFailed.length} failed.`);
+      } catch (err) {
+        printError(`Failed to synchronize custom skills: ${err}`);
       }
-      const totalCustom = CUSTOM_SKILLS.length;
-      printSuccess(`${customSkillsInstalled}/${totalCustom} custom skills processed`);
     }
   }
   const statusMsg = isUpdate ? "Configuration updated!" : "Installation complete!";
@@ -2532,7 +3436,7 @@ Usage:
 Options:
   --skills=yes|no        Install bundled skills (default: yes)
   --companion=ask|yes|no Install desktop companion binary and enable config
-                         (default: ask; prompt defaults to yes)
+                         (default: ask; prompt defaults to no)
   --preset=<name>        Active generated config preset (default: openai)
   --background-subagents=ask|yes|no
                           Persist required OpenCode background subagent env