@wpro-eng/opencode-config 1.0.2 → 1.2.0

package/dist/index.js

@@ -7494,7 +7494,6 @@ var NEVER = INVALID;
 // src/config.ts
 import { existsSync, readFileSync } from "fs";
 import { dirname, join as join2 } from "path";
-import { homedir as homedir2 } from "os";
 
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -8301,7 +8300,6 @@ var ParseErrorCode;
 })(ParseErrorCode || (ParseErrorCode = {}));
 
 // src/constants.ts
-var TEAM_REPO_URL = "git@github.com:wpromote/opencode-config.git";
 var REPO_SHORT_NAME = "opencode-config";
 var CONFIG_FILENAMES = ["wpromote.json", "wpromote.jsonc"];
 
@@ -8347,7 +8345,6 @@ function logWarn(message) {
 // src/config.ts
 var UserConfigSchema = exports_external.object({
   disable: exports_external.array(exports_external.string()).default([]),
-  ref: exports_external.string().optional(),
   installMethod: exports_external.enum(["link", "copy"]).default("link"),
   dryRun: exports_external.boolean().default(false),
   orchestration: exports_external.object({
@@ -8408,7 +8405,6 @@ var UserConfigSchema = exports_external.object({
 }).strict();
 var DEFAULT_CONFIG = {
   disable: [],
-  ref: undefined,
   installMethod: "link",
   dryRun: false,
   orchestration: {
@@ -8463,7 +8459,8 @@ var DEFAULT_CONFIG = {
 };
 function getConfigPaths() {
   const projectDir = join2(process.cwd(), ".opencode");
-  const userDir = join2(homedir2(), ".config", "opencode");
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  const userDir = join2(home, ".config", "opencode");
   return [
     ...CONFIG_FILENAMES.map((filename) => join2(projectDir, filename)),
     ...CONFIG_FILENAMES.map((filename) => join2(userDir, filename))
@@ -8503,9 +8500,8 @@ function loadConfigWithLocation() {
   return { config: DEFAULT_CONFIG, configDir: null };
 }
 
-// src/git.ts
+// src/assets.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
-var {$ } = globalThis.Bun;
 import * as path from "path";
 import * as fs from "fs";
 
@@ -8628,201 +8624,27 @@ function discoverInstructions(repoPath) {
   return instructions;
 }
 
-// src/repo.ts
-function getRepoId(url) {
-  const sshMatch = url.match(/^git@([^:]+):(.+?)(\.git)?$/);
-  if (sshMatch) {
-    const host = sshMatch[1];
-    const p = sshMatch[2].replace(/\//g, "-");
-    return `${host}-${p}`;
-  }
-  const httpsMatch = url.match(/^https?:\/\/([^/]+)\/(.+?)(\.git)?$/);
-  if (httpsMatch) {
-    const host = httpsMatch[1];
-    const p = httpsMatch[2].replace(/\//g, "-");
-    return `${host}-${p}`;
-  }
-  return url.replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 100);
-}
-
-// src/git.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 3,
-  initialDelayMs: 1000,
-  maxDelayMs: 30000,
-  backoffMultiplier: 2
-};
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function withRetry(operation, operationName, config = DEFAULT_RETRY_CONFIG) {
-  let lastError;
-  let delay = config.initialDelayMs;
-  for (let attempt = 0;attempt <= config.maxRetries; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error;
-      const isNetworkError = isNetworkRelatedError(lastError);
-      if (!isNetworkError) {
-        throw lastError;
-      }
-      if (attempt >= config.maxRetries) {
-        logError(`${operationName} failed after ${config.maxRetries + 1} attempts: ${lastError.message}`);
-        throw lastError;
-      }
-      logWarn(`${operationName} failed (attempt ${attempt + 1}/${config.maxRetries + 1}), retrying in ${delay}ms: ${lastError.message}`);
-      await sleep(delay);
-      delay = Math.min(delay * config.backoffMultiplier, config.maxDelayMs);
-    }
-  }
-  throw lastError || new Error(`${operationName} failed`);
-}
-function isNetworkRelatedError(error) {
-  const message = error.message.toLowerCase();
-  const networkPatterns = [
-    "could not resolve host",
-    "connection refused",
-    "connection timed out",
-    "connection reset",
-    "network is unreachable",
-    "no route to host",
-    "temporary failure in name resolution",
-    "ssl",
-    "tls",
-    "certificate",
-    "handshake",
-    "unable to access",
-    "couldn't connect",
-    "failed to connect",
-    "ssh_exchange_identification",
-    "kex_exchange_identification",
-    "connection closed by remote host",
-    "early eof",
-    "unexpected disconnect",
-    "remote end hung up",
-    "the remote end hung up unexpectedly"
-  ];
-  return networkPatterns.some((pattern) => message.includes(pattern));
-}
-var CACHE_BASE = path.join(process.env.HOME || "~", ".cache", "opencode", "wpromote-config", "repos");
+// src/assets.ts
 var DISCOVERY_LIMITS = {
   maxFiles: 100,
   maxFileSize: 256 * 1024,
   maxDepth: 10
 };
-function getRepoPath(url) {
-  return path.join(CACHE_BASE, getRepoId(url));
-}
-function isCloned(repoPath) {
-  return fs.existsSync(path.join(repoPath, ".git"));
-}
-async function cloneRepo(url, repoPath, retryConfig = DEFAULT_RETRY_CONFIG) {
-  fs.mkdirSync(path.dirname(repoPath), { recursive: true });
-  await withRetry(async () => {
-    const result = await $`git clone ${url} ${repoPath}`.quiet().nothrow();
-    if (result.exitCode !== 0) {
-      const stderr = result.stderr.toString().trim();
-      const stdout = result.stdout.toString().trim();
-      const output = [stderr, stdout].filter(Boolean).join(`
-`) || `exit code ${result.exitCode}`;
-      throw new Error(`git clone failed: ${output}`);
-    }
-  }, `git clone ${url}`, retryConfig);
-}
-async function fetchAndCheckout(repoPath, ref, retryConfig = DEFAULT_RETRY_CONFIG) {
-  const beforeCommit = await $`git -C ${repoPath} rev-parse HEAD`.quiet();
-  const beforeHash = beforeCommit.stdout.toString().trim();
-  await withRetry(async () => {
-    const fetchResult = await $`git -C ${repoPath} fetch --all --prune`.quiet();
-    if (fetchResult.exitCode !== 0) {
-      const stderr = fetchResult.stderr.toString().trim();
-      const stdout = fetchResult.stdout.toString().trim();
-      const output = [stderr, stdout].filter(Boolean).join(`
-`) || `exit code ${fetchResult.exitCode}`;
-      throw new Error(`git fetch failed: ${output}`);
-    }
-  }, `git fetch (${repoPath})`, retryConfig);
-  const checkoutResult = await $`git -C ${repoPath} checkout ${ref}`.quiet().nothrow();
-  if (checkoutResult.exitCode !== 0) {
-    const stderr = checkoutResult.stderr.toString().trim();
-    const stdout = checkoutResult.stdout.toString().trim();
-    const output = [stderr, stdout].filter(Boolean).join(`
-`) || `exit code ${checkoutResult.exitCode}`;
-    throw new Error(`git checkout ${ref} failed: ${output}`);
-  }
-  const isBranch = await $`git -C ${repoPath} symbolic-ref -q HEAD`.quiet().nothrow();
-  if (isBranch.exitCode === 0) {
-    await withRetry(async () => {
-      const pullResult = await $`git -C ${repoPath} pull --ff-only`.quiet();
-      if (pullResult.exitCode !== 0) {
-        const stderr = pullResult.stderr.toString().trim();
-        const stdout = pullResult.stdout.toString().trim();
-        const output = [stderr, stdout].filter(Boolean).join(`
-`) || `exit code ${pullResult.exitCode}`;
-        throw new Error(`git pull failed: ${output}`);
-      }
-    }, `git pull (${repoPath})`, retryConfig);
-  }
-  const afterCommit = await $`git -C ${repoPath} rev-parse HEAD`.quiet();
-  const afterHash = afterCommit.stdout.toString().trim();
-  return beforeHash !== afterHash;
-}
-async function getCurrentRef(repoPath) {
-  const branchResult = await $`git -C ${repoPath} symbolic-ref --short HEAD`.quiet().nothrow();
-  if (branchResult.exitCode === 0)
-    return branchResult.stdout.toString().trim();
-  const commitResult = await $`git -C ${repoPath} rev-parse --short HEAD`.quiet();
-  return commitResult.stdout.toString().trim();
-}
-async function syncTeamRepository(ref) {
-  const effectiveRef = ref ?? "main";
-  const repoId = getRepoId(TEAM_REPO_URL);
-  const repoPath = getRepoPath(TEAM_REPO_URL);
-  const shortName = REPO_SHORT_NAME;
-  let updated = false;
-  let error;
-  try {
-    if (!isCloned(repoPath)) {
-      if (fs.existsSync(repoPath)) {
-        fs.rmSync(repoPath, { recursive: true, force: true });
-      }
-      await cloneRepo(TEAM_REPO_URL, repoPath);
-      updated = true;
-    }
-    updated = await fetchAndCheckout(repoPath, effectiveRef) || updated;
-  } catch (err) {
-    error = err instanceof Error ? err.message : String(err);
-  }
-  let skills = [];
-  let agents = [];
-  let commands = [];
-  let plugins = [];
-  let instructions = [];
-  let mcps = [];
-  let currentRef = effectiveRef;
-  if (isCloned(repoPath)) {
-    currentRef = await getCurrentRef(repoPath);
-    skills = await discoverSkills(repoPath);
-    agents = await discoverAgents(repoPath);
-    commands = await discoverCommands(repoPath);
-    plugins = await discoverPlugins(repoPath, shortName);
-    instructions = discoverInstructions(repoPath);
-    mcps = await discoverMcps(repoPath);
-  }
+async function discoverAssets(packageRoot) {
+  const skills = await discoverSkills(packageRoot);
+  const agents = await discoverAgents(packageRoot);
+  const commands = await discoverCommands(packageRoot);
+  const plugins = await discoverPlugins(packageRoot, REPO_SHORT_NAME);
+  const instructions = discoverInstructions(packageRoot);
+  const mcps = await discoverMcps(packageRoot);
   return {
-    repoId,
-    repoPath,
-    shortName,
-    ref: currentRef,
+    shortName: REPO_SHORT_NAME,
     skills,
     agents,
     commands,
     plugins,
     instructions,
-    mcps,
-    updated,
-    error
+    mcps
   };
 }
 async function discoverSkills(repoPath) {
@@ -9148,10 +8970,10 @@ async function discoverMcps(repoPath) {
 // src/install.ts
 import * as path3 from "path";
 import * as fs3 from "fs";
-var {$: $3 } = globalThis.Bun;
+var {$: $2 } = globalThis.Bun;
 
 // src/copy.ts
-var {$: $2 } = globalThis.Bun;
+var {$ } = globalThis.Bun;
 import * as fs2 from "fs";
 import * as path2 from "path";
 var rsyncAvailable = null;
@@ -9160,7 +8982,7 @@ async function detectRsync() {
     return rsyncAvailable;
   }
   try {
-    const result = await $2`which rsync`.quiet();
+    const result = await $`which rsync`.quiet();
     rsyncAvailable = result.exitCode === 0;
   } catch {
     rsyncAvailable = false;
@@ -9175,7 +8997,7 @@ async function copyWithRsync(source, target) {
     } else if (stat.isDirectory()) {}
   }
   fs2.mkdirSync(path2.dirname(target), { recursive: true });
-  const result = await $2`rsync -a --delete ${source}/ ${target}/`.quiet();
+  const result = await $`rsync -a --delete ${source}/ ${target}/`.quiet();
   if (result.exitCode !== 0) {
     throw new Error(`rsync failed: ${result.stderr.toString()}`);
   }
@@ -9402,7 +9224,7 @@ function hasLocalConflict(skillName) {
 }
 async function findGitRoot(startPath) {
   try {
-    const result = await $3`git -C ${startPath} rev-parse --show-toplevel`.quiet();
+    const result = await $2`git -C ${startPath} rev-parse --show-toplevel`.quiet();
     if (result.exitCode === 0) {
       return result.stdout.toString().trim();
     }
@@ -9450,9 +9272,9 @@ ${gitignoreEntry}
 // src/plugin-install.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { homedir as homedir3 } from "os";
-var PLUGIN_DIR_PLURAL = path4.join(homedir3(), ".config", "opencode", "plugins");
-var PLUGIN_DIR_SINGULAR = path4.join(homedir3(), ".config", "opencode", "plugin");
+import { homedir as homedir2 } from "os";
+var PLUGIN_DIR_PLURAL = path4.join(homedir2(), ".config", "opencode", "plugins");
+var PLUGIN_DIR_SINGULAR = path4.join(homedir2(), ".config", "opencode", "plugin");
 var REMOTE_PREFIX = "_remote_";
 function removePathIfExists(targetPath) {
   try {
@@ -9625,8 +9447,8 @@ function findBrokenUnmanagedPluginLinks(pluginDir) {
 // src/mcp-install.ts
 import * as fs5 from "fs";
 import * as path5 from "path";
-import { homedir as homedir4 } from "os";
-var DEFAULT_MCP_DIR = path5.join(homedir4(), ".config", "opencode", "mcp");
+import { homedir as homedir3 } from "os";
+var DEFAULT_MCP_DIR = path5.join(homedir3(), ".config", "opencode", "mcp");
 function getMcpPluginsSubdirForRepo(repoShortName) {
   return path5.join("_plugins", repoShortName);
 }
@@ -9826,131 +9648,12 @@ function createDisableMatcher(disable) {
   };
 }
 
-// src/lock.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
-import * as os from "os";
-var DEFAULT_TIMEOUT_MS = 30000;
-var POLL_INTERVAL_MS = 500;
-var STALE_THRESHOLD_MS = 5 * 60 * 1000;
-function getLockPath() {
-  return path6.join(getRepoPath(TEAM_REPO_URL), ".sync.lock");
-}
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    if (err.code === "EPERM") {
-      return true;
-    }
-    return false;
-  }
-}
-function isLockStale(lockData) {
-  if (lockData.hostname === os.hostname()) {
-    if (!isProcessRunning(lockData.pid)) {
-      logDebug(`Lock held by dead process ${lockData.pid}, considering stale`);
-      return true;
-    }
-  }
-  const age = Date.now() - lockData.timestamp;
-  if (age > STALE_THRESHOLD_MS) {
-    if (lockData.hostname !== os.hostname()) {
-      logDebug(`Lock from remote host ${lockData.hostname} is ${Math.round(age / 1000)}s old, considering stale`);
-      return true;
-    }
-  }
-  return false;
-}
-function readLockData() {
-  const lockPath = getLockPath();
-  try {
-    const content = fs6.readFileSync(lockPath, "utf8");
-    const data = JSON.parse(content);
-    if (typeof data.pid !== "number" || typeof data.hostname !== "string" || typeof data.timestamp !== "number") {
-      logDebug("Invalid lockfile structure, ignoring");
-      return;
-    }
-    return data;
-  } catch {
-    return;
-  }
-}
-function removeLockFile() {
-  const lockPath = getLockPath();
-  try {
-    fs6.unlinkSync(lockPath);
-  } catch {}
-}
-function tryAcquireLock() {
-  const lockPath = getLockPath();
-  fs6.mkdirSync(path6.dirname(lockPath), { recursive: true });
-  const existingLock = readLockData();
-  if (existingLock) {
-    if (isLockStale(existingLock)) {
-      logDebug("Removing stale lock");
-      removeLockFile();
-    } else {
-      return false;
-    }
-  }
-  try {
-    const data = {
-      pid: process.pid,
-      hostname: os.hostname(),
-      timestamp: Date.now()
-    };
-    fs6.writeFileSync(lockPath, JSON.stringify(data, null, 2), { flag: "wx" });
-    return true;
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      return false;
-    }
-    throw err;
-  }
-}
-async function acquireLock(timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const startTime = Date.now();
-  while (true) {
-    if (tryAcquireLock()) {
-      logDebug("Acquired sync lock");
-      return { acquired: true };
-    }
-    const elapsed = Date.now() - startTime;
-    if (elapsed >= timeoutMs) {
-      const lockData = readLockData();
-      const holder = lockData ? `pid ${lockData.pid} on ${lockData.hostname}` : "unknown process";
-      return {
-        acquired: false,
-        error: `Failed to acquire sync lock after ${Math.round(elapsed / 1000)}s (held by ${holder})`
-      };
-    }
-    await new Promise((resolve4) => setTimeout(resolve4, POLL_INTERVAL_MS));
-  }
-}
-function releaseLock() {
-  const lockData = readLockData();
-  if (lockData && lockData.pid === process.pid && lockData.hostname === os.hostname()) {
-    removeLockFile();
-    logDebug("Released sync lock");
-  }
-}
-async function withLock(fn, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const lockResult = await acquireLock(timeoutMs);
-  if (!lockResult.acquired) {
-    throw new Error(lockResult.error);
-  }
-  try {
-    return await fn();
-  } finally {
-    releaseLock();
-  }
-}
+// src/index.ts
+import * as path8 from "path";
 
 // src/mcp-schema.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
@@ -10098,7 +9801,7 @@ function validateMcpConfig(obj) {
 }
 function validateMcpFile(mcpJsonPath) {
   try {
-    const content = fs7.readFileSync(mcpJsonPath, "utf-8");
+    const content = fs6.readFileSync(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return validateMcpConfig(parsed);
   } catch (err) {
@@ -10117,7 +9820,7 @@ function validateMcpFile(mcpJsonPath) {
   }
 }
 function validateMcpInfo(mcp) {
-  const mcpJsonPath = mcp.path.endsWith(".json") ? mcp.path : path7.join(mcp.path, "mcp.json");
+  const mcpJsonPath = mcp.path.endsWith(".json") ? mcp.path : path6.join(mcp.path, "mcp.json");
   const result = validateMcpFile(mcpJsonPath);
   for (const warning of result.warnings) {
     logWarn(`MCP '${mcp.name}': ${warning}`);
@@ -10135,82 +9838,57 @@ function filterValidMcps(mcps) {
 }
 
 // src/status.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
-var STATUS_BASE = path8.join(process.env.HOME || "~", ".cache", "opencode", "wpromote-config");
+import * as fs7 from "fs";
+import * as path7 from "path";
+var STATUS_BASE = path7.join(process.env.HOME || "~", ".cache", "opencode", "wpromote-config");
 function getStatusFilePath() {
-  return path8.join(STATUS_BASE, `${REPO_SHORT_NAME}.sync-status.json`);
+  return path7.join(STATUS_BASE, `${REPO_SHORT_NAME}.plugin-status.json`);
 }
-function readSyncStatus() {
+function writePluginStatus(status) {
   const statusPath = getStatusFilePath();
+  const dir = path7.dirname(statusPath);
+  fs7.mkdirSync(dir, { recursive: true });
+  fs7.writeFileSync(statusPath, JSON.stringify(status, null, 2));
+  logDebug(`Wrote plugin status to ${statusPath}`);
+}
+function getPluginVersion() {
   try {
-    const content = fs8.readFileSync(statusPath, "utf-8");
-    return JSON.parse(content);
+    const pkgPath = path7.resolve(import.meta.dir, "..", "package.json");
+    const content = fs7.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version ?? null;
   } catch {
     return null;
   }
 }
-function writeSyncStatus(status) {
-  const statusPath = getStatusFilePath();
-  const dir = path8.dirname(statusPath);
-  fs8.mkdirSync(dir, { recursive: true });
-  fs8.writeFileSync(statusPath, JSON.stringify(status, null, 2));
-  logDebug(`Wrote sync status to ${statusPath}`);
-}
-function updateSyncStatus(data) {
+function updatePluginStatus(data) {
   const status = {
-    lastSyncTime: new Date().toISOString(),
-    currentRef: data.currentRef,
-    installedSkills: data.installedSkills,
-    installedPlugins: data.installedPlugins,
-    installedMcps: data.installedMcps,
-    remoteAgents: data.remoteAgents,
-    remoteCommands: data.remoteCommands,
-    remoteInstructions: data.remoteInstructions,
+    lastLoadTime: new Date().toISOString(),
+    pluginVersion: getPluginVersion(),
+    skillNames: data.skillNames,
+    pluginNames: data.pluginNames,
+    runtimePluginNames: data.runtimePluginNames,
+    mcpNames: data.mcpNames,
+    agentNames: data.agentNames,
+    commandNames: data.commandNames,
+    instructionNames: data.instructionNames,
     skippedConflicts: data.skippedConflicts,
     disabledAssets: data.disabledAssets,
     lastError: null,
     pluginsChanged: data.pluginsChanged
   };
-  writeSyncStatus(status);
-}
-function recordSyncError(error) {
-  const existing = readSyncStatus();
-  const status = existing ?? {
-    lastSyncTime: null,
-    currentRef: null,
-    installedSkills: 0,
-    installedPlugins: 0,
-    installedMcps: 0,
-    remoteAgents: 0,
-    remoteCommands: 0,
-    remoteInstructions: 0,
-    skippedConflicts: 0,
-    disabledAssets: 0,
-    lastError: null,
-    pluginsChanged: false
-  };
-  status.lastError = error;
-  writeSyncStatus(status);
+  writePluginStatus(status);
 }
 
 // src/index.ts
+var PACKAGE_ROOT = path8.resolve(import.meta.dir, "..");
 var initialized = false;
 var REQUIRED_RUNTIME_PLUGINS = ["@tarquinen/opencode-dcp@latest"];
 var DEFAULT_OPENCODE_AGENTS_TO_DISABLE = ["build", "plan"];
-async function performSync(config) {
+async function performLoad(config) {
   const disableMatcher = createDisableMatcher(config.disable);
-  log(config.dryRun ? "[DRY-RUN] Analyzing team configuration..." : "Syncing team configuration...");
-  const result = await syncTeamRepository(config.ref);
-  const degradedSyncMode = Boolean(result.error);
-  if (degradedSyncMode) {
-    const syncError = result.error ?? "Unknown sync error";
-    logError(`\u2717 Failed to sync team repository: ${syncError}`);
-    if (!config.dryRun) {
-      recordSyncError(syncError);
-    }
-    log("Continuing with cached assets in degraded mode");
-  }
+  log(config.dryRun ? "[DRY-RUN] Analyzing team configuration..." : "Loading team configuration...");
+  const result = await discoverAssets(PACKAGE_ROOT);
   if (!config.dryRun) {
     const brokenUnmanagedLinks = findBrokenUnmanagedPluginLinks();
     if (brokenUnmanagedLinks.length > 0) {
@@ -10384,20 +10062,6 @@ async function performSync(config) {
       dryRun: dryRunReport
     };
   }
-  if (degradedSyncMode) {
-    return {
-      result,
-      skippedConflicts,
-      totalSkills: 0,
-      remoteAgents,
-      remoteCommands,
-      remoteMcps,
-      remoteInstructions,
-      pluginsChanged: false,
-      totalPlugins: 0,
-      totalMcps: 0
-    };
-  }
   const filteredResult = { ...result, skills: skillsToInstall };
   const installResults = await createInstallsForRepo(filteredResult, config.installMethod);
   for (const sr of installResults) {
@@ -10408,7 +10072,7 @@ async function performSync(config) {
       logError(`\u2717 Failed to install skill ${sr.skillName}: ${sr.error}`);
     }
   }
-  log(`\u2713 ${result.shortName} (${result.ref}) - ${totalSkills} skills`);
+  log(`\u2713 ${result.shortName} - ${totalSkills} skills`);
   const cleanup = cleanupStaleInstalls(currentSkills);
   if (cleanup.removed.length > 0) {
     log(`Cleaned up ${cleanup.removed.length} stale skill installs`);
@@ -10467,16 +10131,16 @@ async function performSync(config) {
     log(`Cleaned up ${mcpCleanup.removed.length} stale MCP installs`);
   }
   const totalMcps = newMcpInstalls.size;
-  updateSyncStatus({
-    currentRef: result.ref,
-    installedSkills: totalSkills,
-    installedPlugins: totalPlugins,
-    installedMcps: totalMcps,
-    remoteAgents: remoteAgents.size,
-    remoteCommands: remoteCommands.size,
-    remoteInstructions: remoteInstructions.length,
-    skippedConflicts: skippedConflicts.length,
-    disabledAssets: disabledAssets.length,
+  updatePluginStatus({
+    skillNames: skillsToInstall.map((s) => s.name),
+    pluginNames: pluginsToInstall.map((p) => p.name),
+    runtimePluginNames: [...REQUIRED_RUNTIME_PLUGINS],
+    mcpNames: [...remoteMcps.keys()],
+    agentNames: [...remoteAgents.keys()],
+    commandNames: [...remoteCommands.keys()],
+    instructionNames: remoteInstructions.map((p) => p.split("/").pop() ?? p),
+    skippedConflicts,
+    disabledAssets,
     pluginsChanged
   });
   return {
@@ -10554,7 +10218,7 @@ var WpromoteConfigPlugin = async (ctx) => {
     pluginsChanged,
     totalPlugins,
     totalMcps
-  } = await withLock(async () => performSync(userConfig));
+  } = await performLoad(userConfig);
   if (pluginsChanged) {
     log("\u26A0 Plugin changes detected. Restart OpenCode to apply.");
   }
@@ -10700,7 +10364,7 @@ var WpromoteConfigPlugin = async (ctx) => {
 var RemoteSkillsPlugin = WpromoteConfigPlugin;
 var src_default = WpromoteConfigPlugin;
 export {
-  performSync,
+  performLoad,
   src_default as default,
   WpromoteConfigPlugin,
   RemoteSkillsPlugin

package/instruction/getting-started.md

@@ -0,0 +1,24 @@
+# Getting Started with Wpromote OpenCode
+
+Welcome to the Wpromote OpenCode configuration.
+
+## Quick Start
+
+1. Install the plugin
+2. Restart OpenCode
+3. All team configs will be synced automatically
+
+## Configuration
+
+Create `~/.config/opencode/wpromote.json` (or `~/.config/opencode/wpromote.jsonc`) to customize:
+
+```json
+{
+  "disable": ["skill:example"],
+  "installMethod": "link"
+}
+```
+
+## Overriding Team Configs
+
+To override a team skill/agent/command, create a local file with the same name in your personal config directory.