bi-superpowers 1.0.0 → 1.1.1

package/bin/commands/uninstall.js

@@ -40,6 +40,15 @@ const os = require('os');
 const readline = require('readline');
 const { AGENTS, UNIVERSAL_DIR } = require('../lib/agents');
 const { removeMcpConfigForAgent } = require('../lib/mcp-config');
+const {
+  readInstallManifest,
+  removeInstallManifest,
+  getAgentSkillRecord,
+  isManifestOwnedSymlink,
+  samePath,
+  packageKey,
+} = require('../lib/install-manifest');
+const { disableAutoupdate } = require('./autoupdate');
 
 const LEGACY_SESSION_DIR = '.bi-superpowers';
 
@@ -281,7 +290,7 @@ function removeIfEmpty(dir) {
  *
  * @returns {{ action: string, dir?: string, count?: number }}
  */
-function removeAgentSkills(baseDir, agentId, skillNames, dryRun, removeEmpty) {
+function removeAgentSkills(baseDir, agentId, skillNames, dryRun, removeEmpty, manifest = null) {
   const agent = AGENTS[agentId];
   if (agent.dir === UNIVERSAL_DIR) {
     return { action: 'universal' };
@@ -294,14 +303,23 @@ function removeAgentSkills(baseDir, agentId, skillNames, dryRun, removeEmpty) {
   }
 
   if (st.isSymbolicLink()) {
+    const universalTarget = path.join(baseDir, UNIVERSAL_DIR);
+    if (!isManifestOwnedSymlink(manifest, agentId, dir, universalTarget)) {
+      return { action: 'preserved-symlink', dir: agent.dir };
+    }
     if (!dryRun) fs.unlinkSync(dir);
     if (removeEmpty && !dryRun) removeIfEmpty(path.dirname(dir));
     return { action: 'unlinked', dir: agent.dir };
   }
 
   // Real directory (copy fallback or user-managed): remove only our subdirs.
+  const record = getAgentSkillRecord(manifest, agentId);
+  if (!record || record.method !== 'copied' || !samePath(record.path, dir)) {
+    return { action: 'unmanaged-directory', dir: agent.dir, count: 0 };
+  }
   let count = 0;
-  for (const name of skillNames) {
+  const ownedSkills = Array.isArray(record.skills) ? record.skills : skillNames;
+  for (const name of ownedSkills) {
     const sub = path.join(dir, name);
     if (fs.existsSync(sub)) {
       if (!dryRun) fs.rmSync(sub, { recursive: true, force: true });
@@ -321,7 +339,7 @@ function removeAgentSkills(baseDir, agentId, skillNames, dryRun, removeEmpty) {
  *
  * @returns {{ action: string, count?: number }}
  */
-function removeUniversalSkills(baseDir, skillNames, dryRun, removeEmpty) {
+function removeUniversalSkills(baseDir, skillNames, dryRun, removeEmpty, manifest = null) {
   const universal = path.join(baseDir, UNIVERSAL_DIR);
   const st = fs.lstatSync(universal, { throwIfNoEntry: false });
   if (!st) {
@@ -329,12 +347,17 @@ function removeUniversalSkills(baseDir, skillNames, dryRun, removeEmpty) {
   }
 
   if (st.isSymbolicLink()) {
-    if (!dryRun) fs.unlinkSync(universal);
-    return { action: 'unlinked' };
+    return { action: 'preserved-symlink' };
+  }
+
+  const record = manifest && manifest.skills && manifest.skills.universal;
+  if (!record || !samePath(record.path, universal)) {
+    return { action: 'unmanaged-directory', count: 0 };
   }
 
   let count = 0;
-  for (const name of skillNames) {
+  const ownedSkills = Array.isArray(record.skills) ? record.skills : skillNames;
+  for (const name of ownedSkills) {
     const sub = path.join(universal, name);
     if (fs.existsSync(sub)) {
       if (!dryRun) fs.rmSync(sub, { recursive: true, force: true });
@@ -374,13 +397,23 @@ function universalIsFullyReleased(baseDir, selectedAgents) {
  *
  * @returns {{ existed: boolean, path: string }}
  */
-function cleanLegacySessionDir(baseDir, dryRun) {
+function cleanLegacySessionDir(baseDir, dryRun, packageName = 'bi-superpowers') {
   const dir = path.join(baseDir, LEGACY_SESSION_DIR);
-  const existed = fs.existsSync(dir);
-  if (existed && !dryRun) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-  return { existed, path: dir };
+  const candidates = [
+    'auth.json',
+    'session.json',
+    'update-state.json',
+    'autoupdate-state.json',
+    `update-state-${packageKey(packageName)}.json`,
+    `autoupdate-state-${packageKey(packageName)}.json`,
+    `install-manifest-${packageKey(packageName)}.json`,
+  ].map((name) => path.join(dir, name));
+  const existing = candidates.filter((file) => fs.existsSync(file));
+  if (!dryRun) {
+    for (const file of existing) fs.rmSync(file, { force: true });
+    removeIfEmpty(dir);
+  }
+  return { existed: existing.length > 0, path: dir, removed: existing };
 }
 
 /**
@@ -395,7 +428,12 @@ async function uninstallCommand(args, config) {
   const opts = parseArgs(args);
   const baseDir = os.homedir();
   const packageDir = config.packageDir || path.dirname(path.dirname(__dirname));
-  const skillNames = getManagedSkillNames(packageDir);
+  const packageName = config.packageName || 'bi-superpowers';
+  const manifest = readInstallManifest(baseDir, packageName);
+  const skillNames =
+    manifest && manifest.skills && Array.isArray(manifest.skills.names)
+      ? manifest.skills.names
+      : getManagedSkillNames(packageDir);
 
   console.log(
     boxen(
@@ -448,12 +486,29 @@ async function uninstallCommand(args, config) {
     )
   );
 
+  // Uninstall always disables the Claude Code auto-update hook so a removed
+  // package cannot keep reinstalling itself in future sessions.
+  try {
+    if (dry) {
+      console.log(chalk.gray('  · Claude Code auto-update hook would be disabled'));
+    } else {
+      const hook = disableAutoupdate();
+      console.log(
+        hook.removed
+          ? chalk.green('  ✓ Claude Code auto-update hook disabled')
+          : chalk.gray('  – Claude Code auto-update hook was not enabled')
+      );
+    }
+  } catch (err) {
+    console.log(chalk.red(`  ✗ Could not disable Claude Code auto-update: ${err.message}`));
+  }
+
   // Phase 1: skills.
   const skillResults = [];
   if (doSkills) {
     for (const agentId of selectedAgents) {
       try {
-        const result = removeAgentSkills(baseDir, agentId, skillNames, dry, true);
+        const result = removeAgentSkills(baseDir, agentId, skillNames, dry, true, manifest);
         skillResults.push({ agent: AGENTS[agentId].name, ...result });
       } catch (err) {
         skillResults.push({ agent: AGENTS[agentId].name, action: 'error', error: err.message });
@@ -462,7 +517,7 @@ async function uninstallCommand(args, config) {
 
     if (releaseUniversal) {
       try {
-        const uni = removeUniversalSkills(baseDir, skillNames, dry, true);
+        const uni = removeUniversalSkills(baseDir, skillNames, dry, true, manifest);
         skillResults.push({ agent: `${UNIVERSAL_DIR}`, ...uni });
       } catch (err) {
         skillResults.push({ agent: UNIVERSAL_DIR, action: 'error', error: err.message });
@@ -480,6 +535,10 @@ async function uninstallCommand(args, config) {
         console.log(chalk.green(`  ${dry ? '·' : '✓'} ${r.agent}/ (${r.count} skills removed)`));
       } else if (r.action === 'absent') {
         console.log(chalk.gray(`  – ${r.agent}: no managed skills found`));
+      } else if (r.action === 'preserved-symlink') {
+        console.log(chalk.yellow(`  ⚠ ${r.dir || r.agent}: foreign symlink preserved`));
+      } else if (r.action === 'unmanaged-directory') {
+        console.log(chalk.yellow(`  ⚠ ${r.dir || r.agent}: unowned directory preserved`));
       } else if (r.action === 'error') {
         console.log(chalk.red(`  ✗ ${r.agent}: ${r.error}`));
       }
@@ -522,7 +581,7 @@ async function uninstallCommand(args, config) {
   // Phase 3: legacy session dir.
   let legacy = { existed: false };
   if (doExtras) {
-    legacy = cleanLegacySessionDir(baseDir, dry);
+    legacy = cleanLegacySessionDir(baseDir, dry, packageName);
     if (legacy.existed) {
       console.log(
         chalk.green(
@@ -530,6 +589,7 @@ async function uninstallCommand(args, config) {
         )
       );
     }
+    if (!dry) removeInstallManifest(baseDir, packageName);
   }
 
   // Summary.

package/bin/commands/update-check.js

@@ -49,6 +49,12 @@ const HTTPS_TIMEOUT_MS = 5000;
 // `bin/commands/`, it stays null and we fall back to package.json.
 const BUNDLED_INSTALLED_VERSION = null;
 
+// Keep this helper dependency-free because the generator copies this script
+// into every installed skill as a standalone update checker.
+function packageKey(packageName) {
+  return Buffer.from(String(packageName || PACKAGE_NAME), 'utf8').toString('base64url');
+}
+
 // ---------------------------------------------------------------------------
 // Argument parsing
 // ---------------------------------------------------------------------------
@@ -173,12 +179,12 @@ function defaultStateDir() {
   return path.join(os.homedir(), '.bi-superpowers');
 }
 
-function stateFilePath(stateDir) {
-  return path.join(stateDir, 'update-state.json');
+function stateFilePath(stateDir, packageName = PACKAGE_NAME) {
+  return path.join(stateDir, `update-state-${packageKey(packageName)}.json`);
 }
 
-function readState(stateDir) {
-  const filePath = stateFilePath(stateDir);
+function readState(stateDir, packageName = PACKAGE_NAME) {
+  const filePath = stateFilePath(stateDir, packageName);
   if (!fs.existsSync(filePath)) return null;
   try {
     return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -188,13 +194,13 @@ function readState(stateDir) {
   }
 }
 
-function writeState(stateDir, state) {
+function writeState(stateDir, state, packageName = PACKAGE_NAME) {
   fs.mkdirSync(stateDir, { recursive: true });
-  fs.writeFileSync(stateFilePath(stateDir), JSON.stringify(state, null, 2) + '\n');
+  fs.writeFileSync(stateFilePath(stateDir, packageName), JSON.stringify(state, null, 2) + '\n');
 }
 
-function resetState(stateDir) {
-  const filePath = stateFilePath(stateDir);
+function resetState(stateDir, packageName = PACKAGE_NAME) {
+  const filePath = stateFilePath(stateDir, packageName);
   if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
 }
 
@@ -335,22 +341,26 @@ async function main() {
   const packageName = args.packageName || PACKAGE_NAME;
 
   if (args.reset) {
-    resetState(stateDir);
+    resetState(stateDir, packageName);
     return;
   }
 
   if (args.snooze) {
     const now = Date.now();
-    const prior = readState(stateDir) || {};
+    const prior = readState(stateDir, packageName) || {};
     const parsed = parseSnoozeArg(args.snooze, now, prior.snoozeLevel || 0);
     if (parsed.clear) {
-      writeState(stateDir, { ...prior, snoozeUntil: null, snoozeLevel: 0 });
+      writeState(stateDir, { ...prior, snoozeUntil: null, snoozeLevel: 0 }, packageName);
     } else {
-      writeState(stateDir, {
-        ...prior,
-        snoozeUntil: parsed.until,
-        snoozeLevel: parsed.level,
-      });
+      writeState(
+        stateDir,
+        {
+          ...prior,
+          snoozeUntil: parsed.until,
+          snoozeLevel: parsed.level,
+        },
+        packageName
+      );
     }
     return;
   }
@@ -362,7 +372,7 @@ async function main() {
   }
 
   const now = Date.now();
-  let state = readState(stateDir);
+  let state = readState(stateDir, packageName);
 
   // Snooze short-circuits everything except --force.
   if (!args.force && isSnoozed(state, now)) {
@@ -383,7 +393,7 @@ async function main() {
         snoozeUntil: (state && state.snoozeUntil) || null,
         snoozeLevel: (state && state.snoozeLevel) || 0,
       };
-      writeState(stateDir, nextState);
+      writeState(stateDir, nextState, packageName);
       state = nextState;
     }
     // If fetched is null (network fail), we keep using the previous cache
@@ -412,6 +422,7 @@ module.exports = {
   readState,
   writeState,
   resetState,
+  stateFilePath,
   fetchLatestVersion,
   readInstalledVersion,
   CACHE_TTL_MS,

package/bin/lib/base-template-smoke.js

@@ -27,6 +27,8 @@ const SMOKE_QUERY_PATTERN = /## Smoke Query\s+```DAX\s+([\s\S]*?)```/i;
 const DAY_MS = 24 * 60 * 60 * 1000;
 const WEEK_MS = 7 * DAY_MS;
 const DEMO_CUSTOMER_COUNT = 210;
+const DEMO_INITIAL_CUSTOMER_COUNT = 90;
+const DEFAULT_START_DATE = new Date(2023, 0, 1);
 
 function extractSmokeQuery(caseMarkdown) {
   const match = caseMarkdown.match(SMOKE_QUERY_PATTERN);
@@ -44,12 +46,6 @@ function formatLocalDate(date) {
   return `${year}-${month}-${day}`;
 }
 
-function addLocalDays(date, days) {
-  const result = new Date(date.getFullYear(), date.getMonth(), date.getDate());
-  result.setDate(result.getDate() + days);
-  return result;
-}
-
 function startOfMondayWeek(date) {
   const result = new Date(date.getFullYear(), date.getMonth(), date.getDate());
   const mondayOffset = (result.getDay() + 6) % 7;
@@ -63,11 +59,25 @@ function countMondayWeeks(startDate, endDate) {
   return Math.floor((lastWeek.getTime() - firstWeek.getTime()) / WEEK_MS) + 1;
 }
 
-function estimateVentasRows(weekCount, customerCount = DEMO_CUSTOMER_COUNT) {
+function estimateVentasRows(
+  weekCount,
+  customerCount = DEMO_CUSTOMER_COUNT,
+  initialCustomerCount = DEMO_INITIAL_CUSTOMER_COUNT
+) {
+  const initial = Math.min(initialCustomerCount, Math.max(0, customerCount - 1));
+  const remaining = customerCount - initial;
   let rows = 0;
 
-  for (let weekNumber = 1; weekNumber <= weekCount; weekNumber++) {
-    rows += Math.min(customerCount, weekNumber * 2);
+  for (let weekIndex = 0; weekIndex < weekCount; weekIndex++) {
+    let active = initial;
+    for (let customerIndex = 0; customerIndex < remaining; customerIndex++) {
+      const acquisitionWeek =
+        remaining <= 1 || weekCount <= 1
+          ? 0
+          : Math.floor((customerIndex * (weekCount - 1)) / (remaining - 1));
+      if (acquisitionWeek <= weekIndex) active++;
+    }
+    rows += active;
   }
 
   return rows;
@@ -79,10 +89,13 @@ function getExpectedSmokeEvidence(referenceDate = new Date()) {
     referenceDate.getMonth(),
     referenceDate.getDate()
   );
-  const minDate = addLocalDays(currentDate, -729);
-  const validationStartDate = addLocalDays(currentDate, -719);
-  const ventasWeeks = countMondayWeeks(minDate, currentDate);
-  const validationWeeks = countMondayWeeks(validationStartDate, currentDate);
+  const minDate = new Date(
+    DEFAULT_START_DATE.getFullYear(),
+    DEFAULT_START_DATE.getMonth(),
+    DEFAULT_START_DATE.getDate()
+  );
+  const maxFactDate = startOfMondayWeek(currentDate);
+  const validationWeeks = countMondayWeeks(minDate, currentDate);
 
   return {
     Metricas: '56',
@@ -93,11 +106,19 @@ function getExpectedSmokeEvidence(referenceDate = new Date()) {
     WindowWeeks: String(validationWeeks),
     FactTablesWithFullWeeks: '13',
     MetricCoverageFailures: '0',
-    MetricDimensionPairs: '379',
+    MetricDimensionPairs: '415',
     MetricDimensionFailures: '0',
-    VentasRows: String(estimateVentasRows(ventasWeeks)),
+    VisibleDimensionFailures: '0',
+    MaxVisibleDimensionValues: '13',
+    BusinessInvariantFailures: '0',
+    YearRangeFailures: '0',
+    TeamRangeFailures: '0',
+    Last365RangeFailures: '0',
+    VentasRows: String(estimateVentasRows(validationWeeks)),
     MinFecha: formatLocalDate(minDate),
-    MaxFecha: formatLocalDate(currentDate),
+    MaxFecha: formatLocalDate(maxFactDate),
+    MaxCalendario: formatLocalDate(currentDate),
+    UltimoClienteNuevo: formatLocalDate(maxFactDate),
   };
 }
 
@@ -196,15 +217,22 @@ async function runBaseTemplateLiveSmokeTest(options = {}) {
   const expected = getExpectedSmokeEvidence(referenceDate);
   const session = sessionFactory(serverPath);
   const attempts = [];
+  const connectionTimeoutMs = options.connectionTimeoutMs || 30_000;
+  const daxTimeoutMs = options.daxTimeoutMs || 210_000;
+  const signal = options.signal;
 
   try {
-    await session.initialize(options.clientInfo);
-
-    const localInstancesResult = await session.callTool('connection_operations', {
-      request: {
-        operation: 'ListLocalInstances',
+    await session.initialize(options.clientInfo, { timeoutMs: connectionTimeoutMs, signal });
+
+    const localInstancesResult = await session.callTool(
+      'connection_operations',
+      {
+        request: {
+          operation: 'ListLocalInstances',
+        },
       },
-    });
+      { timeoutMs: connectionTimeoutMs, signal }
+    );
     const localInstances = normalizeMcpJsonResult(localInstancesResult).data || [];
 
     for (const instance of localInstances) {
@@ -218,31 +246,43 @@ async function runBaseTemplateLiveSmokeTest(options = {}) {
       };
 
       try {
-        await session.callTool('connection_operations', {
-          request: {
-            operation: 'Connect',
-            connectionString: `Provider=MSOLAP;Data Source=localhost:${instance.port};Application Name=MCP-PBIModeling`,
+        await session.callTool(
+          'connection_operations',
+          {
+            request: {
+              operation: 'Connect',
+              connectionString: `Provider=MSOLAP;Data Source=localhost:${instance.port};Application Name=MCP-PBIModeling`,
+            },
           },
-        });
-
-        const connectionsResult = await session.callTool('connection_operations', {
-          request: {
-            operation: 'ListConnections',
+          { timeoutMs: connectionTimeoutMs, signal }
+        );
+
+        const connectionsResult = await session.callTool(
+          'connection_operations',
+          {
+            request: {
+              operation: 'ListConnections',
+            },
           },
-        });
+          { timeoutMs: connectionTimeoutMs, signal }
+        );
         const connections = normalizeMcpJsonResult(connectionsResult).data || [];
         const selectedConnection = selectConnectionForPort(connections, instance.port);
         attempt.connectionName = selectedConnection ? selectedConnection.connectionName : null;
 
-        const daxResult = await session.callTool('dax_query_operations', {
-          request: {
-            operation: 'Execute',
-            connectionName: attempt.connectionName || undefined,
-            timeoutSeconds: 180,
-            maxRows: 1,
-            query: smokeQuery,
+        const daxResult = await session.callTool(
+          'dax_query_operations',
+          {
+            request: {
+              operation: 'Execute',
+              connectionName: attempt.connectionName || undefined,
+              timeoutSeconds: 180,
+              maxRows: 1,
+              query: smokeQuery,
+            },
           },
-        });
+          { timeoutMs: daxTimeoutMs, signal }
+        );
 
         const observed = parseSingleRowCsv(extractCsvText(daxResult));
         attempt.observed = observed;

package/bin/lib/install-manifest.js

@@ -0,0 +1,198 @@
+/**
+ * Install Ownership Manifest
+ * ==========================
+ *
+ * Records the user-level files and links created by `super install`.
+ * Uninstall and future upgrades use this file as proof of ownership instead
+ * of assuming that every similarly named path belongs to bi-superpowers.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const MANIFEST_SCHEMA_VERSION = 1;
+const STATE_DIR = '.bi-superpowers';
+
+function packageKey(packageName) {
+  return Buffer.from(String(packageName || 'bi-superpowers'), 'utf8').toString('base64url');
+}
+
+function manifestFilePath(homeDir, packageName = 'bi-superpowers') {
+  return path.join(homeDir, STATE_DIR, `install-manifest-${packageKey(packageName)}.json`);
+}
+
+function readInstallManifest(homeDir, packageName = 'bi-superpowers') {
+  const file = manifestFilePath(homeDir, packageName);
+  if (!fs.existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (
+      !parsed ||
+      parsed.schemaVersion !== MANIFEST_SCHEMA_VERSION ||
+      parsed.packageName !== packageName
+    ) {
+      return null;
+    }
+    return parsed;
+  } catch (_) {
+    return null;
+  }
+}
+
+function writeInstallManifest(homeDir, manifest) {
+  const packageName = manifest.packageName || 'bi-superpowers';
+  const file = manifestFilePath(homeDir, packageName);
+  const parent = path.dirname(file);
+  fs.mkdirSync(parent, { recursive: true });
+
+  const leaf = fs.lstatSync(file, { throwIfNoEntry: false });
+  if (leaf && leaf.isSymbolicLink()) {
+    throw new Error(`Refusing to overwrite symlinked install manifest: ${file}`);
+  }
+
+  const temp = `${file}.tmp`;
+  const tempLeaf = fs.lstatSync(temp, { throwIfNoEntry: false });
+  if (tempLeaf && tempLeaf.isSymbolicLink()) {
+    throw new Error(`Refusing to overwrite symlinked temporary manifest: ${temp}`);
+  }
+
+  fs.writeFileSync(temp, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+  try {
+    fs.renameSync(temp, file);
+  } catch (error) {
+    // Windows cannot always atomically replace an existing file. The content
+    // is already complete in the sibling temp file, so replace in two steps.
+    if (!['EEXIST', 'EPERM'].includes(error.code)) throw error;
+    fs.rmSync(file, { force: true });
+    fs.renameSync(temp, file);
+  }
+  return file;
+}
+
+function removeInstallManifest(homeDir, packageName = 'bi-superpowers') {
+  const file = manifestFilePath(homeDir, packageName);
+  if (fs.existsSync(file)) fs.unlinkSync(file);
+}
+
+function normalizeForComparison(value) {
+  const resolved = path.resolve(String(value));
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+function samePath(left, right) {
+  if (!left || !right) return false;
+  return normalizeForComparison(left) === normalizeForComparison(right);
+}
+
+function resolveSymlinkTarget(linkPath) {
+  const stat = fs.lstatSync(linkPath, { throwIfNoEntry: false });
+  if (!stat || !stat.isSymbolicLink()) return null;
+  try {
+    const rawTarget = fs.readlinkSync(linkPath);
+    return path.resolve(path.dirname(linkPath), rawTarget);
+  } catch (_) {
+    return null;
+  }
+}
+
+function getAgentSkillRecord(manifest, agentId) {
+  return manifest && manifest.skills && manifest.skills.agents
+    ? manifest.skills.agents[agentId] || null
+    : null;
+}
+
+function isManifestOwnedSymlink(manifest, agentId, linkPath, expectedTarget) {
+  const record = getAgentSkillRecord(manifest, agentId);
+  if (!record || record.method !== 'symlinked') return false;
+  const actualTarget = resolveSymlinkTarget(linkPath);
+  return (
+    samePath(record.path, linkPath) &&
+    samePath(record.target, expectedTarget) &&
+    samePath(actualTarget, expectedTarget)
+  );
+}
+
+/**
+ * One-time migration proof for installs created before manifests existed.
+ * The link must point exactly at the universal directory and that directory
+ * must contain every skill shipped by the package being installed.
+ */
+function isVerifiedLegacyManagedSymlink(linkPath, universalTarget, skillNames) {
+  const actualTarget = resolveSymlinkTarget(linkPath);
+  if (!samePath(actualTarget, universalTarget) || skillNames.length === 0) {
+    return false;
+  }
+  return skillNames.every((skillName) => {
+    const skillFile = path.join(universalTarget, skillName, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) return false;
+    try {
+      return fs.readFileSync(skillFile, 'utf8').includes(`name: ${skillName}`);
+    } catch (_) {
+      return false;
+    }
+  });
+}
+
+function createInstallManifest({
+  packageName,
+  packageVersion,
+  skillNames,
+  universalTarget,
+  agentResults,
+  mcpResults,
+  autoUpdateEnabled,
+}) {
+  const agents = {};
+  for (const result of agentResults) {
+    if (!result.agentId || result.method === 'preserved-foreign') continue;
+    agents[result.agentId] = {
+      method: result.method,
+      path: result.path,
+      target: result.target || null,
+      skills: [...skillNames],
+    };
+  }
+
+  return {
+    schemaVersion: MANIFEST_SCHEMA_VERSION,
+    packageName,
+    packageVersion,
+    installedAt: new Date().toISOString(),
+    skills: {
+      names: [...skillNames],
+      universal: {
+        path: universalTarget,
+        skills: [...skillNames],
+      },
+      agents,
+    },
+    mcp: {
+      servers: ['powerbi-modeling-mcp', 'microsoft-learn'],
+      agents: mcpResults
+        .filter((result) => result.success && result.configPath)
+        .map((result) => ({
+          agentId: result.agentId,
+          configPath: result.configPath,
+        })),
+    },
+    autoUpdate: {
+      enabled: Boolean(autoUpdateEnabled),
+    },
+  };
+}
+
+module.exports = {
+  MANIFEST_SCHEMA_VERSION,
+  STATE_DIR,
+  packageKey,
+  manifestFilePath,
+  readInstallManifest,
+  writeInstallManifest,
+  removeInstallManifest,
+  samePath,
+  resolveSymlinkTarget,
+  getAgentSkillRecord,
+  isManifestOwnedSymlink,
+  isVerifiedLegacyManagedSymlink,
+  createInstallManifest,
+};