@ghl-ai/aw 0.1.57 → 0.1.58-beta.0

package/integrations.mjs

@@ -19,18 +19,10 @@ import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 import { chalk } from './fmt.mjs';
-import {
-  ensureContextModeIntegration,
-  getContextModeIntegrationSummary,
-  removeContextModeIntegration,
-} from './integrations/context-mode.mjs';
 
 const execAsync = promisify(exec);
 const HOME = homedir();
-
-function manifestPath(home = HOME) {
-  return join(home, '.aw_registry', '.integration-manifest.json');
-}
+const MANIFEST_PATH = join(HOME, '.aw_registry', '.integration-manifest.json');
 
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -144,16 +136,6 @@ export const INTEGRATIONS = {
     requiresAuth: false,
     authNote: 'run /graphify . inside your IDE to build the graph whenever you need it',
   },
-
-  'context-mode': {
-    type: 'context-mode',
-    label: 'Context Mode',
-    description: 'Local context-mode MCP server and hook-based context preservation',
-    autoInstall: false,
-    teams: [],
-    requiresAuth: false,
-    authNote: 'Run aw doctor to verify context-mode health.',
-  },
 };
 
 // ────────────────────────────────────────────────────────────────────────────────
@@ -166,27 +148,25 @@ export const BUNDLES = {};
 // MANIFEST MANAGEMENT
 // ────────────────────────────────────────────────────────────────────────────────
 
-export function readManifest(home = HOME) {
-  const filePath = manifestPath(home);
-  if (!existsSync(filePath)) {
+export function readManifest() {
+  if (!existsSync(MANIFEST_PATH)) {
     return { version: 1, installed: {} };
   }
 
   try {
-    return JSON.parse(readFileSync(filePath, 'utf8'));
+    return JSON.parse(readFileSync(MANIFEST_PATH, 'utf8'));
   } catch {
     return { version: 1, installed: {} };
   }
 }
 
-export function writeManifest(manifest, home = HOME) {
-  const filePath = manifestPath(home);
-  mkdirSync(join(filePath, '..'), { recursive: true });
-  writeFileSync(filePath, JSON.stringify(manifest, null, 2) + '\n');
+export function writeManifest(manifest) {
+  mkdirSync(join(HOME, '.aw_registry'), { recursive: true });
+  writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2) + '\n');
 }
 
-export function isInstalled(key, options = {}) {
-  const manifest = readManifest(options.home);
+export function isInstalled(key) {
+  const manifest = readManifest();
   const entry = manifest.installed[key];
   if (!entry) return false;
   // Backward compat: pre-existing entries have no `status` field — treat as installed.
@@ -195,35 +175,25 @@ export function isInstalled(key, options = {}) {
   return entry.status !== 'skipped';
 }
 
-function recordInstalled(key, type, options = {}) {
-  if (options.dryRun) return;
-  const manifest = readManifest(options.home);
+function recordInstalled(key, type) {
+  const manifest = readManifest();
   manifest.installed[key] = {
     type,
     status: 'installed',
     installedAt: new Date().toISOString(),
-    ...(options.extra || {}),
   };
-  writeManifest(manifest, options.home);
+  writeManifest(manifest);
 }
 
-function recordSkipped(key, type, reason, options = {}) {
-  if (options.dryRun) return;
-  const manifest = readManifest(options.home);
+function recordSkipped(key, type, reason) {
+  const manifest = readManifest();
   manifest.installed[key] = {
     type,
     status: 'skipped',
     reason,
     installedAt: new Date().toISOString(),
   };
-  writeManifest(manifest, options.home);
-}
-
-function removeInstalled(key, options = {}) {
-  if (options.dryRun) return;
-  const manifest = readManifest(options.home);
-  delete manifest.installed[key];
-  writeManifest(manifest, options.home);
+  writeManifest(manifest);
 }
 
 // ────────────────────────────────────────────────────────────────────────────────
@@ -449,7 +419,7 @@ async function resolveCliInvocation(cliCommand, pythonCmd, installer) {
   }
 }
 
-async function runPythonCli(integration, key, { silent = false, home = HOME } = {}) {
+async function runPythonCli(integration, key, { silent = false } = {}) {
   const spinner = silent ? null : fmt.spinner();
 
   // 1. Detect Python ≥ minPython.
@@ -457,7 +427,7 @@ async function runPythonCli(integration, key, { silent = false, home = HOME } =
   const py = await detectPython(integration.minPython);
   if (!py) {
     if (!silent) spinner.stop(chalk.yellow('Python not found'));
-    recordSkipped(key, 'python-cli', 'python-not-found', { home });
+    recordSkipped(key, 'python-cli', 'python-not-found');
     if (!silent) {
       fmt.logWarn(
         `${integration.label} skipped — Python ${integration.minPython.major}.${integration.minPython.minor}+ required.`,
@@ -589,7 +559,7 @@ async function runClaudePlugin(installCmd, { silent = false, marketplaceSource =
 // UNIVERSAL INSTALLER (OS-detected master script — covers all IDEs in one shot)
 // ────────────────────────────────────────────────────────────────────────────────
 
-async function runUniversalInstaller(integration, key, { silent = false, home = HOME } = {}) {
+async function runUniversalInstaller(integration, key, { silent = false } = {}) {
   const spinner = silent ? null : fmt.spinner();
 
   if (!silent) spinner.start(`Installing ${integration.label} for all detected IDEs...`);
@@ -636,7 +606,7 @@ async function runUniversalInstaller(integration, key, { silent = false, home =
               'Skipped',
             );
           }
-          recordSkipped(key, 'universal-installer', 'wsl-not-found', { home });
+          recordSkipped(key, 'universal-installer', 'wsl-not-found');
           return false;
         }
       }
@@ -679,60 +649,13 @@ async function runUniversalInstaller(integration, key, { silent = false, home =
 // INTEGRATION INSTALLER
 // ────────────────────────────────────────────────────────────────────────────────
 
-function successResult(key, integration, extra = {}) {
-  return { success: true, key, integration, ...extra };
-}
-
-function failureResult(key, integration, error, extra = {}) {
-  return { success: false, key, integration, error, ...extra };
-}
-
-export function integrationSucceeded(result) {
-  return result === true || result?.success === true;
-}
-
-export async function installIntegration(key, options = {}) {
-  const { silent = false } = options;
-  const home = options.home || HOME;
-  const dryRun = options.dryRun === true;
+export async function installIntegration(key, { silent = false } = {}) {
   const integration = INTEGRATIONS[key];
   if (!integration) {
     throw new Error(`Unknown integration: ${key}`);
   }
 
-  if (integration.type === 'context-mode') {
-    const result = ensureContextModeIntegration(home, {
-      ...options,
-      home,
-      env: options.env || process.env,
-      dryRun,
-    });
-    if (dryRun) {
-      return successResult(key, integration, result);
-    }
-    if (result.binary.present && result.complete) {
-      recordInstalled(key, integration.type, {
-        home,
-        extra: {
-          binaryPath: result.binary.path,
-          version: result.binary.version,
-        },
-      });
-      return successResult(key, integration, result);
-    }
-    return failureResult(
-      key,
-      integration,
-      result.binary.present ? 'partial-config' : (result.warnings?.[0] || 'binary-missing'),
-      result,
-    );
-  }
-
-  if (dryRun) {
-    return successResult(key, integration, { plannedInstall: true });
-  }
-
-  if (isInstalled(key, { home })) {
+  if (isInstalled(key)) {
     if (!silent) fmt.logWarn(`${integration.label} is already installed`);
     return false;
   }
@@ -741,7 +664,7 @@ export async function installIntegration(key, options = {}) {
     if (integration.type === 'plugin') {
       // PLUGIN: Run claude plugin install
       await runClaudePlugin(integration.installCmd, { silent, marketplaceSource: integration.marketplaceSource ?? null });
-      recordInstalled(key, 'plugin', { home });
+      recordInstalled(key, 'plugin');
 
       if (!silent) {
         fmt.logSuccess(`${integration.label} plugin installed`);
@@ -776,7 +699,7 @@ export async function installIntegration(key, options = {}) {
         integration.mcpUrl
       );
 
-      recordInstalled(key, 'remote-mcp', { home });
+      recordInstalled(key, 'remote-mcp');
 
       if (!silent) {
         fmt.logSuccess(`${integration.label} added to MCP servers`);
@@ -786,10 +709,10 @@ export async function installIntegration(key, options = {}) {
       }
     } else if (integration.type === 'python-cli') {
       // PYTHON CLI: pip-install + run post-install + per-project hooks
-      const ok = await runPythonCli(integration, key, { silent, home });
+      const ok = await runPythonCli(integration, key, { silent });
       if (!ok) return false;  // skipped (e.g. Python missing) — manifest already recorded
 
-      recordInstalled(key, 'python-cli', { home });
+      recordInstalled(key, 'python-cli');
 
       if (!silent) {
         fmt.logSuccess(`${integration.label} installed`);
@@ -799,9 +722,9 @@ export async function installIntegration(key, options = {}) {
       }
     } else if (integration.type === 'universal-installer') {
       // UNIVERSAL INSTALLER: OS-detected master script, covers all IDEs in one shot
-      const ok = await runUniversalInstaller(integration, key, { silent, home });
+      const ok = await runUniversalInstaller(integration, key, { silent });
       if (!ok) return false;  // skipped (e.g. WSL not found) — manifest already recorded
-      recordInstalled(key, 'universal-installer', { home });
+      recordInstalled(key, 'universal-installer');
 
       if (!silent) {
         fmt.logSuccess(`${integration.label} installed across all detected IDEs`);
@@ -825,22 +748,13 @@ export async function installIntegration(key, options = {}) {
 // INTEGRATION REMOVER
 // ────────────────────────────────────────────────────────────────────────────────
 
-export async function removeIntegration(key, options = {}) {
-  const { silent = false } = options;
-  const home = options.home || HOME;
-  const dryRun = options.dryRun === true;
+export async function removeIntegration(key, { silent = false } = {}) {
   const integration = INTEGRATIONS[key];
   if (!integration) {
     throw new Error(`Unknown integration: ${key}`);
   }
 
-  if (integration.type === 'context-mode') {
-    const result = removeContextModeIntegration(home, { dryRun });
-    removeInstalled(key, { home, dryRun });
-    return successResult(key, integration, result);
-  }
-
-  if (!isInstalled(key, { home })) {
+  if (!isInstalled(key)) {
     if (!silent) fmt.logWarn(`${integration.label} is not installed`);
     return false;
   }
@@ -934,7 +848,9 @@ export async function removeIntegration(key, options = {}) {
     }
 
     // Remove from manifest
-    removeInstalled(key, { home });
+    const manifest = readManifest();
+    delete manifest.installed[key];
+    writeManifest(manifest);
 
     return true;
   } catch (e) {
@@ -949,8 +865,8 @@ export async function removeIntegration(key, options = {}) {
 // HELPERS
 // ────────────────────────────────────────────────────────────────────────────────
 
-export function getInstalledList(options = {}) {
-  const manifest = readManifest(options.home);
+export function getInstalledList() {
+  const manifest = readManifest();
   // Only return entries actually installed — skipped entries (e.g. Python missing)
   // shouldn't show up as "installed" to the rest of the system.
   return Object.entries(manifest.installed)
@@ -958,34 +874,6 @@ export function getInstalledList(options = {}) {
     .map(([key]) => key);
 }
 
-export function getIntegrationSummary(key, options = {}) {
-  const integration = INTEGRATIONS[key];
-  if (!integration) return null;
-  if (integration.type === 'context-mode') {
-    return {
-      ...getContextModeIntegrationSummary(options.home || HOME, options),
-      label: integration.label,
-      description: integration.description,
-      type: integration.type,
-    };
-  }
-  const installed = isInstalled(key, options);
-  return {
-    name: key,
-    label: integration.label,
-    description: integration.description,
-    type: integration.type,
-    installed,
-    configured: installed,
-    state: installed ? 'installed' : 'available',
-    summary: installed ? `${integration.label} installed` : `${integration.label} available`,
-  };
-}
-
-export function getIntegrationSummaries(options = {}) {
-  return Object.keys(INTEGRATIONS).map(key => getIntegrationSummary(key, options));
-}
-
 export function suggestForTeam(namespace) {
   if (!namespace) return [];
 
@@ -1007,8 +895,7 @@ export function suggestForTeam(namespace) {
 // AUTO-INSTALL (called from init.mjs - installs suggested integrations)
 // ────────────────────────────────────────────────────────────────────────────────
 
-export async function autoInstallIntegrations(team, options = {}) {
-  const { silent = false, installer = installIntegration } = options;
+export async function autoInstallIntegrations(team, { silent = false, installer = installIntegration } = {}) {
   // Get suggested integrations for this team
   const suggested = suggestForTeam(team);
   if (!suggested || suggested.length === 0) {
@@ -1016,7 +903,7 @@ export async function autoInstallIntegrations(team, options = {}) {
   }
 
   // Only install if they're not already installed
-  const toInstall = suggested.filter((key) => !isInstalled(key, options));
+  const toInstall = suggested.filter((key) => !isInstalled(key));
   if (toInstall.length === 0) {
     return [];
   }
@@ -1027,8 +914,8 @@ export async function autoInstallIntegrations(team, options = {}) {
 
   const installed = [];
   for (const key of toInstall) {
-    const result = await installer(key, { ...options, silent });
-    if (integrationSucceeded(result)) {
+    const success = await installer(key, { silent });
+    if (success) {
       installed.push(INTEGRATIONS[key].label);
     }
   }
@@ -1124,8 +1011,8 @@ export async function promptAndInstall(team, { silent = false } = {}) {
   // Install all
   const installed = [];
   for (const key of toInstall) {
-    const result = await installIntegration(key, { silent: false });
-    if (integrationSucceeded(result)) {
+    const success = await installIntegration(key, { silent: false });
+    if (success) {
       installed.push(INTEGRATIONS[key].label);
     }
   }

package/link.mjs

@@ -11,11 +11,29 @@ function forceSymlink(target, linkPath) {
   symlinkSync(target, linkPath);
 }
 
+function linkNestedSkillRoot(target, linkPath, { silent }) {
+  try {
+    forceSymlink(target, linkPath);
+    return true;
+  } catch (error) {
+    if (!silent) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Could not link nested skill ${linkPath} -> ${target}: ${message}`);
+    }
+    return false;
+  }
+}
+
 const IDE_DIRS = ['.claude', '.cursor', '.codex'];
 // Per-file symlink types
 const FILE_TYPES = ['agents'];
 const ALL_KNOWN_TYPES = new Set([...FILE_TYPES, 'skills', 'commands', 'evals', 'references', 'docs']);
 
+function realHomeDir() {
+  const HOME = homedir();
+  try { return realpathSync(HOME); } catch { return HOME; }
+}
+
 /**
  * List namespace directories inside .aw_registry/ (skip dotfiles).
  */
@@ -36,6 +54,32 @@ function listDirs(dir) {
     .map(d => d.name);
 }
 
+/**
+ * Recursively find directories below a skills/ folder that are real skill roots.
+ * A real skill root is a directory containing SKILL.md. Once found, do not
+ * descend further so bundled references/scripts inside that skill are preserved.
+ */
+function findSkillRootDirs(skillsDir) {
+  const results = [];
+  function walk(dir, segments) {
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+
+      const childDir = join(dir, entry.name);
+      const childSegments = [...segments, entry.name];
+      if (existsSync(join(childDir, 'SKILL.md'))) {
+        results.push({ skillDirPath: childDir, segments: childSegments });
+        continue;
+      }
+
+      walk(childDir, childSegments);
+    }
+  }
+  walk(skillsDir, []);
+  return results;
+}
+
 /**
  * Recursively find directories named `typeName` within `nsDir`,
  * skipping other known type directories to avoid false matches.
@@ -77,7 +121,7 @@ function cleanIdeSymlinks(cwd) {
     cleanSymlinksRecursive(ideDir);
   }
   // Also clean .agents/skills/ (global only — Codex reads from ~/.agents/skills/)
-  const HOME = homedir();
+  const HOME = realHomeDir();
   if (cwd === HOME) {
     const agentsSkillsDir = join(cwd, '.agents', 'skills');
     if (existsSync(agentsSkillsDir)) cleanSymlinksRecursive(agentsSkillsDir);
@@ -140,7 +184,8 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
   // where $HOME may be /var/... but process.cwd() resolves to /private/var/...
   try { cwd = realpathSync(cwd); } catch { /* use as-is */ }
 
-  const GLOBAL_AW_DIR = join(homedir(), '.aw_registry');
+  const HOME = realHomeDir();
+  const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
   let awDir = awDirOverride || getLocalRegistryDir(cwd, GLOBAL_AW_DIR);
   try { awDir = realpathSync(awDir); } catch { /* use as-is if it doesn't exist */ }
   if (!existsSync(awDir)) return 0;
@@ -185,6 +230,19 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
           try { forceSymlink(relTarget, linkPath); created++; } catch { /* best effort */ }
         }
       }
+
+      for (const { skillDirPath, segments: skillSegments } of findSkillRootDirs(skillsDir)) {
+        if (skillSegments.length <= 1) continue;
+        const flat = [ns, ...segments, ...skillSegments].join('-');
+
+        for (const ide of IDE_DIRS) {
+          const linkDir = join(cwd, ide, 'skills');
+          mkdirSync(linkDir, { recursive: true });
+          const linkPath = join(linkDir, flat);
+          const relTarget = relative(linkDir, skillDirPath);
+          if (linkNestedSkillRoot(relTarget, linkPath, { silent })) created++;
+        }
+      }
     }
   }
 
@@ -246,7 +304,7 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
   }
 
   // Codex per-skill symlinks: ~/.agents/skills/<name> (global only)
-  if (cwd === homedir()) {
+  if (cwd === HOME) {
     const agentsSkillsDir = join(cwd, '.agents/skills');
     for (const ns of namespaces) {
       for (const { typeDirPath: skillsDir, segments } of findNestedTypeDirs(join(awDir, ns), 'skills')) {
@@ -258,6 +316,14 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
           const relTarget = relative(agentsSkillsDir, targetPath);
           try { forceSymlink(relTarget, linkPath); created++; } catch { /* best effort */ }
         }
+
+        for (const { skillDirPath, segments: skillSegments } of findSkillRootDirs(skillsDir)) {
+          if (skillSegments.length <= 1) continue;
+          const flat = [ns, ...segments, ...skillSegments].join('-');
+          const linkPath = join(agentsSkillsDir, flat);
+          const relTarget = relative(agentsSkillsDir, skillDirPath);
+          if (linkNestedSkillRoot(relTarget, linkPath, { silent })) created++;
+        }
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.57",
+  "version": "0.1.58-beta.0",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
@@ -22,7 +22,6 @@
     "link.mjs",
     "manifest.mjs",
     "mcp.mjs",
-    "package-manager.mjs",
     "paths.mjs",
     "plan.mjs",
     "registry.mjs",
@@ -55,9 +54,9 @@
   "license": "MIT",
   "scripts": {
     "test": "yarn test:vitest && yarn test:node",
-    "test:vitest": "vitest run --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs tests/integrations tests/package-manager.test.mjs",
+    "test:vitest": "vitest run --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs",
     "test:node": "node tests/run-node-tests.mjs",
-    "test:watch": "vitest --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs tests/integrations tests/package-manager.test.mjs",
+    "test:watch": "vitest --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs",
     "preuninstall": "node bin.js nuke 2>/dev/null || true"
   },
   "publishConfig": {

package/update.mjs

@@ -9,7 +9,7 @@
 //   .volta/  → volta install     pnpm/  → pnpm add -g
 //   else     → npm i -g
 
-import { existsSync, readFileSync, mkdirSync, writeFileSync, statSync, rmSync, appendFileSync } from 'node:fs';
+import { readFileSync, mkdirSync, writeFileSync, statSync, rmSync, appendFileSync } from 'node:fs';
 import { exec as execCb, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
 import { join, dirname } from 'node:path';
@@ -39,16 +39,15 @@ const LOG_MAX_ENTRIES = 50;
 
 const SELF_PATH = fileURLToPath(import.meta.url);
 
-function detectPM(selfPath = SELF_PATH) {
-  const normalizedPath = String(selfPath || '').replace(/\\/g, '/');
-  if (normalizedPath.includes('/.volta/')) return 'volta';
-  if (normalizedPath.includes('/pnpm/')) return 'pnpm';
+function detectPM() {
+  if (SELF_PATH.includes('/.volta/')) return 'volta';
+  if (SELF_PATH.includes('/pnpm/')) return 'pnpm';
   return 'npm';
 }
 
 const PM = detectPM();
 
-export function getInstallCmd(version = 'latest') {
+function getInstallCmd(version = 'latest') {
   const spec = `${PKG_NAME}@${version}`;
   if (PM === 'volta') return `volta install ${spec}`;
   if (PM === 'pnpm') return `pnpm add -g ${spec}`;
@@ -92,36 +91,23 @@ function compareVersions(a, b) {
 // After install, re-resolve where the package actually landed and read
 // its package.json. Falls back to getLocalVersion() (our own bundle).
 
-export function getInstalledPackageRoot(options = {}) {
-  const packageManager = options.packageManager || PM;
-  const runner = options.execSync || execSync;
+function getInstalledVersion() {
   try {
-    if (packageManager === 'volta') {
+    if (PM === 'volta') {
       // Volta resolves via its own image; ask it directly
-      const resolved = runner('volta which aw', {
+      const resolved = execSync('volta which aw', {
         encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
       }).trim();
-      const imageRoot = join(resolved, '..', '..');
-      const packageRoot = join(imageRoot, 'lib', 'node_modules', PKG_NAME);
-      return existsSync(join(packageRoot, 'package.json')) ? packageRoot : imageRoot;
+      const pkgRoot = join(resolved, '..', '..');
+      return JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8')).version;
     }
 
     // npm / pnpm: read from the global prefix
-    const prefix = runner('npm prefix -g', {
+    const prefix = execSync('npm prefix -g', {
       encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
     }).trim();
-    if (packageManager === 'pnpm') {
-      return join(prefix, 'node_modules', PKG_NAME);
-    }
-    return join(prefix, 'lib', 'node_modules', PKG_NAME);
-  } catch {
-    return dirname(SELF_PATH);
-  }
-}
-
-function getInstalledVersion() {
-  try {
-    return JSON.parse(readFileSync(join(getInstalledPackageRoot(), 'package.json'), 'utf8')).version;
+    const pkgPath = join(prefix, 'lib', 'node_modules', PKG_NAME, 'package.json');
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
   } catch {
     return getLocalVersion();
   }
@@ -214,8 +200,7 @@ export function autoUpdate(result) {
     execSync(cmd, { stdio: 'pipe', timeout: 60_000 });
     const installed = getInstalledVersion();
     const ok = compareVersions(installed, result.current) > 0;
-    const packageRoot = getInstalledPackageRoot();
-    const entry = { ts: new Date().toISOString(), pm: PM, cmd, from: result.current, to: installed, packageRoot, ok };
+    const entry = { ts: new Date().toISOString(), pm: PM, cmd, from: result.current, to: installed, ok };
     appendLog(entry);
     return { status: ok ? 'upgraded' : 'failed', ...entry };
   } catch (e) {