@exchanet/enet 1.0.9 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exchanet/enet",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "enet — exchanet methods manager. Install, scaffold and manage AI coding methods.",
   "bin": {
     "enet": "src/index.js"

package/src/commands/install.js

@@ -4,7 +4,7 @@ import fs from 'fs-extra'
 import path from 'path'
 import readline from 'readline'
 import { detectSystemAgents, getInstallPath, AGENTS } from '../utils/agent-detector.js'
-import { getMethod, fetchFromGitHub } from '../utils/registry.js'
+import { getMethod, fetchFromGitHub, readInstallRecord, writeInstallRecord } from '../utils/registry.js'
 
 export async function installCommand(methodId, options) {
   // 1. Load method from registry
@@ -21,11 +21,19 @@ export async function installCommand(methodId, options) {
   console.log(chalk.bold(`\n  ◆ ${method.name}`))
   console.log(chalk.dim(`  ${method.description}\n`))
 
-  // 2. Determine target agents
+  // 2. Read existing install record — know what is already installed
+  const record = await readInstallRecord(methodId)
+  const alreadyInstalled = new Set(record?.agents ?? [])
+
+  if (alreadyInstalled.size > 0) {
+    console.log(chalk.dim(`  Already installed for: ${[...alreadyInstalled].join(', ')}\n`))
+  }
+
+  // 3. Determine target agents
   let targetAgents = []
 
   if (options.agent) {
-    // --agent flag: skip detection, install for this specific agent only
+    // --agent flag: bypass detection and checkbox entirely
     if (!AGENTS[options.agent]) {
       console.log(chalk.red(`  ✗ Unknown agent: "${options.agent}"`))
       console.log(chalk.dim(`  Valid: ${Object.keys(AGENTS).filter(k => k !== 'generic').join(', ')}\n`))
@@ -34,23 +42,20 @@ export async function installCommand(methodId, options) {
     targetAgents = [{ key: options.agent, ...AGENTS[options.agent] }]
 
   } else {
-    // Detect all agents installed on the system
     const detected = await detectSystemAgents()
 
     if (detected.length === 0) {
       console.log(chalk.yellow('  ⚠ No AI agents detected on this system.'))
-      console.log(chalk.dim(`  Use ${chalk.white('--agent <name>')} to force an agent.`))
+      console.log(chalk.dim(`  Use ${chalk.white('--agent <n>')} to force an agent.`))
       console.log(chalk.dim(`  Valid: ${Object.keys(AGENTS).filter(k => k !== 'generic').join(', ')}\n`))
       process.exit(1)
     }
 
-    // 3. Show checkbox selection — always, even with 1 agent detected
-    //    This is the core UX fix: user always chooses, never surprised
     if (options.all) {
-      // --all flag skips the prompt
       targetAgents = detected
     } else {
-      targetAgents = await checkboxSelect(detected, method)
+      // Always show checkbox — even with 1 agent, even on re-run
+      targetAgents = await checkboxSelect(detected, method, alreadyInstalled)
     }
 
     if (targetAgents.length === 0) {
@@ -61,66 +66,74 @@ export async function installCommand(methodId, options) {
 
   console.log()
 
-  // 4. Install for each selected agent
+  // 4. Install each selected agent
+  const newlyInstalled = []
   let schemaInstalled = false
+
   for (const agent of targetAgents) {
-    await installForAgent(method, agent, options, schemaInstalled)
+    const ok = await installForAgent(method, agent, options, schemaInstalled)
     schemaInstalled = true
+    if (ok) newlyInstalled.push(agent.key)
   }
 
+  // 5. Persist updated install record
+  const updatedAgents = [...new Set([...alreadyInstalled, ...newlyInstalled])]
+  await writeInstallRecord(methodId, { agents: updatedAgents, version: method.version })
+
   printHints(methodId)
 }
 
 // ─────────────────────────────────────────────────────────────────
 // Checkbox selection UI
+//
+// Shows all detected agents with tags:
+//   — installed   already present on disk for this method
+//   — new         detected but never installed for this method
 // ─────────────────────────────────────────────────────────────────
 
-async function checkboxSelect(detected, method) {
-  // Build list: detected agents that have an adapter in this method come first,
-  // then show unavailable ones as disabled so user knows what exists
-  const available = detected.filter(a => method.adapters[a.key] || method.adapters['generic'])
+async function checkboxSelect(detected, method, alreadyInstalled = new Set()) {
+  const available   = detected.filter(a =>  method.adapters[a.key] || method.adapters['generic'])
   const unavailable = detected.filter(a => !method.adapters[a.key] && !method.adapters['generic'])
 
   if (available.length === 0) {
     console.log(chalk.yellow('  ⚠ No adapters available for your detected agents.'))
-    console.log(chalk.dim(`  Available adapters in this method: ${Object.keys(method.adapters).join(', ')}\n`))
+    console.log(chalk.dim(`  Adapters in this method: ${Object.keys(method.adapters).join(', ')}\n`))
     process.exit(1)
   }
 
-  // Initial state: all available agents pre-checked
   const items = available.map(a => ({
-    agent: a,
-    checked: true,
+    agent:       a,
+    checked:     true,
+    installed:   alreadyInstalled.has(a.key),
     usesGeneric: !method.adapters[a.key]
   }))
 
-  console.log(chalk.white('  Agents detected on your system:\n'))
+  console.log(chalk.white('  Select adapters to install:\n'))
 
   return new Promise((resolve) => {
     let cursor = 0
 
+    const lineCount = () => items.length + (unavailable.length > 0 ? 3 : 2) + 2
+
     const render = () => {
-      // Move cursor up to redraw (after first render)
-      const lines = items.length + 6
-      if (render.drawn) process.stdout.write(`\x1B[${lines}A`)
+      if (render.drawn) process.stdout.write(`\x1B[${lineCount()}A`)
       render.drawn = true
 
       items.forEach((item, i) => {
         const isCursor = i === cursor
-        const box = item.checked ? chalk.green('[✓]') : chalk.dim('[ ]')
-        const arrow = isCursor ? chalk.cyan(' ❯ ') : '   '
-        const name = isCursor ? chalk.white(item.agent.name) : chalk.dim(item.agent.name)
-        const tag = item.usesGeneric ? chalk.dim(' (generic adapter)') : ''
-        process.stdout.write(`${arrow}${box} ${name}${tag}\n`)
+        const box     = item.checked     ? chalk.green('[✓]')           : chalk.dim('[ ]')
+        const arrow   = isCursor         ? chalk.cyan(' ❯ ')            : '   '
+        const name    = isCursor         ? chalk.white(item.agent.name) : chalk.dim(item.agent.name)
+        const status  = item.installed   ? chalk.dim(' — installed')    : chalk.yellow(' — new')
+        const generic = item.usesGeneric ? chalk.dim(' (generic adapter)') : ''
+        process.stdout.write(`${arrow}${box} ${name}${status}${generic}\n`)
       })
 
       if (unavailable.length > 0) {
-        process.stdout.write(chalk.dim(`\n  Not available for: ${unavailable.map(a => a.name).join(', ')}\n`))
-      } else {
-        process.stdout.write('\n')
+        process.stdout.write(chalk.dim(`\n  No adapter for: ${unavailable.map(a => a.name).join(', ')}\n`))
       }
-
-      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A select all · Enter confirm\n\n'))
+      process.stdout.write('\n')
+      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A all · Enter confirm · Ctrl+C cancel\n\n'))
     }
 
     render()
@@ -131,28 +144,25 @@ async function checkboxSelect(detected, method) {
 
     process.stdin.on('data', (key) => {
       const k = key.toString()
-
-      if (k === '\u001b[A') {                      // arrow up
-        cursor = (cursor - 1 + items.length) % items.length
+      if      (k === '\u001b[A') { cursor = (cursor - 1 + items.length) % items.length; render() }
+      else if (k === '\u001b[B') { cursor = (cursor + 1) % items.length; render() }
+      else if (k === ' ')        { items[cursor].checked = !items[cursor].checked; render() }
+      else if (k === 'a' || k === 'A') {
+        const all = items.every(i => i.checked)
+        items.forEach(i => { i.checked = !all })
         render()
-      } else if (k === '\u001b[B') {               // arrow down
-        cursor = (cursor + 1) % items.length
-        render()
-      } else if (k === ' ') {                      // space: toggle current
-        items[cursor].checked = !items[cursor].checked
-        render()
-      } else if (k === 'a' || k === 'A') {         // A: toggle all
-        const allChecked = items.every(i => i.checked)
-        items.forEach(i => { i.checked = !allChecked })
-        render()
-      } else if (k === '\r' || k === '\n') {       // Enter: confirm
+      }
+      else if (k === '\r' || k === '\n') {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
         process.stdin.pause()
         rl.close()
         const selected = items.filter(i => i.checked).map(i => i.agent)
-        console.log(chalk.dim(`\n  Installing for: ${selected.map(a => a.name).join(', ')}\n`))
+        if (selected.length > 0) {
+          console.log(chalk.dim(`\n  Installing for: ${selected.map(a => a.name).join(', ')}\n`))
+        }
         resolve(selected)
-      } else if (k === '\u0003') {                 // Ctrl+C
+      }
+      else if (k === '\u0003') {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
         process.stdin.pause()
         rl.close()
@@ -165,41 +175,44 @@ async function checkboxSelect(detected, method) {
 
 // ─────────────────────────────────────────────────────────────────
 // Install for one agent
+// Exported so update.js can reuse it without duplication
+// Returns true on success, false on failure/skip
 // ─────────────────────────────────────────────────────────────────
 
-async function installForAgent(method, agent, options, skipExtras = false) {
-  const isGlobal = options.global || false
-
-  // Use the agent-specific adapter if available, fall back to generic
-  const adapterKey = method.adapters[agent.key] ? agent.key : 'generic'
+export async function installForAgent(method, agent, options = {}, skipExtras = false) {
+  const isGlobal    = options.global || false
+  const adapterKey  = method.adapters[agent.key] ? agent.key : 'generic'
   const adapterPath = method.adapters[adapterKey]
 
   if (!adapterPath) {
     console.log(chalk.yellow(`  ⚠ ${agent.name} — no adapter found, skipping`))
-    return
+    return false
   }
 
   if (isGlobal && !agent.globalInstallDir) {
     console.log(chalk.yellow(`  ⚠ ${agent.name} — global install not supported, skipping`))
-    return
+    return false
   }
 
-  const spinner = ora(`Installing for ${agent.name}${isGlobal ? ' (global)' : ''}...`).start()
+  const spinner = ora(`${agent.name}${isGlobal ? ' (global)' : ''}...`).start()
 
   try {
-    const content = await fetchFromGitHub(method.repo, adapterPath)
+    const content     = await fetchFromGitHub(method.repo, adapterPath)
     const installPath = getInstallPath(agent, method.id, { global: isGlobal })
 
     await fs.ensureDir(path.dirname(installPath))
 
-    // Windsurf: append to .windsurfrules instead of overwriting
+    // Windsurf: append to .windsurfrules — replace existing section if already present
     if (agent.key === 'windsurf' && await fs.pathExists(installPath)) {
       const existing = await fs.readFile(installPath, 'utf8')
       if (existing.includes(method.name)) {
-        spinner.warn(chalk.yellow(`${agent.name} — already installed`))
-        return
+        const marker = '\n\n---\n\n'
+        const idx    = existing.indexOf(method.name)
+        const before = existing.substring(0, existing.lastIndexOf(marker, idx) + marker.length)
+        await fs.writeFile(installPath, before + content)
+      } else {
+        await fs.appendFile(installPath, `\n\n---\n\n${content}`)
       }
-      await fs.appendFile(installPath, `\n\n---\n\n${content}`)
     } else {
       await fs.writeFile(installPath, content)
     }
@@ -210,24 +223,25 @@ async function installForAgent(method, agent, options, skipExtras = false) {
 
   } catch (err) {
     spinner.fail(chalk.red(`${agent.name} — ${err.message}`))
-    return
+    return false
   }
 
-  // Download extras (schema, etc.) — only once across all agents
+  // Extras (schema, manifests…) — downloaded once across all agents
   if (!skipExtras && method.extras) {
     for (const [key, filePath] of Object.entries(method.extras)) {
-      const extraSpinner = ora(`Fetching ${key}...`).start()
+      const s = ora(`Fetching ${key}...`).start()
       try {
-        const extraContent = await fetchFromGitHub(method.repo, filePath)
-        const extraOut = path.join(process.cwd(), path.basename(filePath))
-        await fs.writeFile(extraOut, extraContent)
-        extraSpinner.succeed(chalk.dim(`${key} → ${path.basename(filePath)}`))
+        const content = await fetchFromGitHub(method.repo, filePath)
+        await fs.writeFile(path.join(process.cwd(), path.basename(filePath)), content)
+        s.succeed(chalk.dim(`${key} → ${path.basename(filePath)}`))
       } catch {
-        extraSpinner.warn(chalk.dim(`${key} not available (non-critical)`))
+        s.warn(chalk.dim(`${key} not available (non-critical)`))
       }
     }
     console.log()
   }
+
+  return true
 }
 
 // ─────────────────────────────────────────────────────────────────
@@ -241,7 +255,7 @@ function printHints(methodId) {
     console.log(chalk.dim('  2. Agent declares architecture — confirm it'))
     console.log(chalk.dim('  3. Agent builds Core → modules → Admin Panel'))
     console.log()
-    console.log(chalk.dim(`  ${chalk.white('enet new module <name>')}   scaffold your first module`))
+    console.log(chalk.dim(`  ${chalk.white('enet new module <n>')}   scaffold your first module`))
     console.log(chalk.dim(`  ${chalk.white('enet validate')}             check manifests at any time\n`))
   }
   if (methodId === 'pdca-t') {

package/src/commands/update.js

@@ -1,12 +1,18 @@
 import chalk from 'chalk'
 import ora from 'ora'
 import fs from 'fs-extra'
-import { getAllMethods, getMethod, fetchFromGitHub } from '../utils/registry.js'
-import { detectAgent, getInstallPath } from '../utils/agent-detector.js'
+import path from 'path'
+import readline from 'readline'
+import { getAllMethods, getMethod, fetchFromGitHub, readInstallRecord, writeInstallRecord } from '../utils/registry.js'
+import { detectSystemAgents, getInstallPath, AGENTS } from '../utils/agent-detector.js'
+import { installForAgent } from './install.js'
 
 export async function updateCommand(methodId, options) {
   const spinner = ora('Fetching registry...').start()
-  const [allMethods, agent] = await Promise.all([getAllMethods(), detectAgent()])
+  const [allMethods, detectedAgents] = await Promise.all([
+    getAllMethods(),
+    detectSystemAgents()
+  ])
   spinner.stop()
 
   const targets = methodId
@@ -18,30 +24,191 @@ export async function updateCommand(methodId, options) {
     process.exit(1)
   }
 
-  console.log(chalk.white(`\n  Updating methods...\n`))
+  console.log(chalk.bold('\n  ◆ enet update\n'))
 
-  let updated = 0, skipped = 0
+  let totalUpdated = 0, totalAdded = 0, totalSkipped = 0
 
   for (const method of targets) {
-    const installPath = getInstallPath(agent, method.id)
-    if (!await fs.pathExists(installPath)) { skipped++; continue }
+    const record = await readInstallRecord(method.id)
 
-    const s = ora(`Updating ${method.name}...`).start()
-    try {
-      const adapterPath = method.adapters[agent.key] ?? method.adapters.generic
-      const content = await fetchFromGitHub(method.repo, adapterPath)
-      await fs.writeFile(installPath, content)
-      s.succeed(chalk.green(`${method.name} updated`))
-      updated++
-    } catch (err) {
-      s.fail(chalk.yellow(`${method.name} — ${err.message}`))
+    // Skip methods not installed at all
+    if (!record || record.agents.length === 0) {
+      totalSkipped++
+      console.log(chalk.dim(`  ${method.name} — not installed, skipping`))
+      continue
+    }
+
+    console.log(chalk.white(`  ${method.name}`))
+    console.log(chalk.dim(`  Installed for: ${record.agents.join(', ')}\n`))
+
+    // Agents already installed for this method
+    const installedAgents = record.agents
+      .map(key => AGENTS[key] ? { key, ...AGENTS[key] } : null)
+      .filter(Boolean)
+
+    // Agents newly detected on system but NOT yet installed for this method
+    const newAgents = detectedAgents.filter(a =>
+      !record.agents.includes(a.key) &&
+      (method.adapters[a.key] || method.adapters['generic'])
+    )
+
+    // ── 1. Update already-installed adapters ────────────────────
+    if (!options.addOnly) {
+      for (const agent of installedAgents) {
+        const ok = await updateOneAdapter(method, agent, options)
+        if (ok) totalUpdated++
+      }
+    }
+
+    // ── 2. Offer to add newly detected agents ───────────────────
+    if (newAgents.length > 0 && !options.updateOnly) {
+      console.log(chalk.yellow(`\n  New agents detected since last install:\n`))
+
+      let agentsToAdd = []
+      if (options.all) {
+        agentsToAdd = newAgents
+        console.log(chalk.dim(`  Adding all: ${newAgents.map(a => a.name).join(', ')}\n`))
+      } else {
+        agentsToAdd = await checkboxSelectNew(newAgents, method)
+      }
+
+      for (const agent of agentsToAdd) {
+        const ok = await installForAgent(method, agent, options, true)
+        if (ok) {
+          totalAdded++
+          record.agents.push(agent.key)
+        }
+      }
+
+      // Save updated record with newly added agents
+      await writeInstallRecord(method.id, { agents: record.agents, version: method.version })
+
+    } else if (newAgents.length === 0 && !options.addOnly) {
+      console.log(chalk.dim(`  No new agents detected.\n`))
     }
   }
 
+  // ── Summary ──────────────────────────────────────────────────
+  console.log(chalk.dim('  ─────────────────────────────'))
+  if (totalUpdated > 0) console.log(chalk.green(`  ✓ ${totalUpdated} adapter${totalUpdated !== 1 ? 's' : ''} updated`))
+  if (totalAdded > 0)   console.log(chalk.green(`  ✓ ${totalAdded} new adapter${totalAdded !== 1 ? 's' : ''} installed`))
+  if (totalSkipped > 0) console.log(chalk.dim(`    ${totalSkipped} method${totalSkipped !== 1 ? 's' : ''} not installed, skipped`))
+  if (totalUpdated === 0 && totalAdded === 0 && totalSkipped === 0) {
+    console.log(chalk.dim('  Everything is up to date.'))
+  }
   console.log()
-  if (updated === 0 && skipped > 0) {
-    console.log(chalk.dim(`  No methods installed to update.\n`))
-  } else {
-    console.log(chalk.dim(`  ${updated} updated, ${skipped} not installed\n`))
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Update a single already-installed adapter
+// Re-downloads from GitHub and overwrites the local file
+// ─────────────────────────────────────────────────────────────────
+
+async function updateOneAdapter(method, agent, options = {}) {
+  const isGlobal    = options.global || false
+  const adapterKey  = method.adapters[agent.key] ? agent.key : 'generic'
+  const adapterPath = method.adapters[adapterKey]
+
+  if (!adapterPath) {
+    console.log(chalk.dim(`  ${agent.name} — no adapter in registry, skipping`))
+    return false
+  }
+
+  const installPath = getInstallPath(agent, method.id, { global: isGlobal })
+  const exists  = await fs.pathExists(installPath)
+  const action  = exists ? 'Updating' : 'Restoring'
+  const s = ora(`${action} ${agent.name}...`).start()
+
+  try {
+    const content = await fetchFromGitHub(method.repo, adapterPath)
+    await fs.ensureDir(path.dirname(installPath))
+
+    // Windsurf: replace existing section, don't append duplicates
+    if (agent.key === 'windsurf' && exists) {
+      const existing = await fs.readFile(installPath, 'utf8')
+      if (existing.includes(method.name)) {
+        const marker = '\n\n---\n\n'
+        const idx    = existing.indexOf(method.name)
+        const before = existing.substring(0, existing.lastIndexOf(marker, idx) + marker.length)
+        await fs.writeFile(installPath, before + content)
+      } else {
+        await fs.appendFile(installPath, `\n\n---\n\n${content}`)
+      }
+    } else {
+      await fs.writeFile(installPath, content)
+    }
+
+    s.succeed(chalk.green(`${agent.name} — ${action.toLowerCase()}d`))
+    console.log(chalk.dim(`  → ${installPath}\n`))
+    return true
+
+  } catch (err) {
+    s.fail(chalk.red(`${agent.name} — ${err.message}`))
+    return false
   }
 }
+
+// ─────────────────────────────────────────────────────────────────
+// Checkbox for new agents only (shown during update)
+// ─────────────────────────────────────────────────────────────────
+
+async function checkboxSelectNew(newAgents, method) {
+  const items = newAgents.map(a => ({
+    agent:       a,
+    checked:     true,
+    usesGeneric: !method.adapters[a.key]
+  }))
+
+  return new Promise((resolve) => {
+    let cursor = 0
+    const lineCount = () => items.length + 4
+
+    const render = () => {
+      if (render.drawn) process.stdout.write(`\x1B[${lineCount()}A`)
+      render.drawn = true
+
+      items.forEach((item, i) => {
+        const isCursor = i === cursor
+        const box     = item.checked     ? chalk.green('[✓]')           : chalk.dim('[ ]')
+        const arrow   = isCursor         ? chalk.cyan(' ❯ ')            : '   '
+        const name    = isCursor         ? chalk.white(item.agent.name) : chalk.dim(item.agent.name)
+        const generic = item.usesGeneric ? chalk.dim(' (generic adapter)') : ''
+        process.stdout.write(`${arrow}${box} ${name}${generic}\n`)
+      })
+
+      process.stdout.write('\n')
+      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A all · Enter confirm · Ctrl+C cancel\n\n'))
+    }
+
+    render()
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    if (process.stdin.isTTY) process.stdin.setRawMode(true)
+    process.stdin.resume()
+
+    process.stdin.on('data', (key) => {
+      const k = key.toString()
+      if      (k === '\u001b[A') { cursor = (cursor - 1 + items.length) % items.length; render() }
+      else if (k === '\u001b[B') { cursor = (cursor + 1) % items.length; render() }
+      else if (k === ' ')        { items[cursor].checked = !items[cursor].checked; render() }
+      else if (k === 'a' || k === 'A') {
+        const all = items.every(i => i.checked)
+        items.forEach(i => { i.checked = !all })
+        render()
+      }
+      else if (k === '\r' || k === '\n') {
+        if (process.stdin.isTTY) process.stdin.setRawMode(false)
+        process.stdin.pause()
+        rl.close()
+        resolve(items.filter(i => i.checked).map(i => i.agent))
+      }
+      else if (k === '\u0003') {
+        if (process.stdin.isTTY) process.stdin.setRawMode(false)
+        process.stdin.pause()
+        rl.close()
+        console.log('\n')
+        process.exit(0)
+      }
+    })
+  })
+}

package/src/utils/{agent-detector.js → agent_detector.js}

@@ -9,9 +9,9 @@ export const AGENTS = {
     name: 'Cursor',
     systemSignals: [
       path.join(HOME, '.cursor'),
-      path.join(HOME, 'Library', 'Application Support', 'Cursor'),
-      path.join(HOME, 'AppData', 'Roaming', 'Cursor'),
-      path.join(HOME, '.config', 'Cursor'),
+      path.join(HOME, 'Library', 'Application Support', 'Cursor'),   // macOS
+      path.join(HOME, 'AppData', 'Roaming', 'Cursor'),               // Windows
+      path.join(HOME, '.config', 'Cursor'),                          // Linux
     ],
     projectSignals: ['.cursor/rules', '.cursor'],
     projectInstallDir: '.cursor/rules',
@@ -24,8 +24,8 @@ export const AGENTS = {
     name: 'Windsurf',
     systemSignals: [
       path.join(HOME, '.codeium', 'windsurf'),
-      path.join(HOME, 'Library', 'Application Support', 'Windsurf'),
-      path.join(HOME, 'AppData', 'Roaming', 'Windsurf'),
+      path.join(HOME, 'Library', 'Application Support', 'Windsurf'), // macOS
+      path.join(HOME, 'AppData', 'Roaming', 'Windsurf'),             // Windows
     ],
     projectSignals: ['.windsurfrules', '.windsurf'],
     projectInstallDir: '.',
@@ -39,11 +39,13 @@ export const AGENTS = {
     name: 'Antigravity (Google)',
     systemSignals: [
       path.join(HOME, '.gemini', 'antigravity'),
-      path.join(HOME, 'Library', 'Application Support', 'Google', 'Antigravity'),
-      path.join(HOME, 'AppData', 'Roaming', 'Google', 'Antigravity'),
+      path.join(HOME, 'Library', 'Application Support', 'Google', 'Antigravity'), // macOS
+      path.join(HOME, 'AppData', 'Roaming', 'Google', 'Antigravity'),             // Windows
     ],
     projectSignals: ['.agent/rules', '.agent'],
     projectInstallDir: '.agent/rules',
+    // globalInstallDir is a base — getInstallPath() resolves the full path dynamically:
+    // ~/.gemini/antigravity/skills/method-{id}/SKILL.md
     globalInstallDir: path.join(HOME, '.gemini', 'antigravity', 'skills'),
     globalFilename: 'SKILL.md',
     filename: 'enet-{id}.md',
@@ -65,13 +67,16 @@ export const AGENTS = {
 
   copilot: {
     name: 'GitHub Copilot',
+    // Copilot is a VS Code extension — detect by checking the extensions folder
+    // for a github.copilot-* subfolder, not just the presence of .vscode/
     systemSignals: [
-      path.join(HOME, '.vscode', 'extensions'),
-      path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'extensions'),
-      path.join(HOME, 'AppData', 'Roaming', 'Code', 'User', 'extensions'),
-      path.join(HOME, '.vscode-server', 'extensions'),
+      path.join(HOME, '.vscode', 'extensions'),                                         // Linux / Windows
+      path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'extensions'), // macOS
+      path.join(HOME, 'AppData', 'Roaming', 'Code', 'User', 'extensions'),             // Windows alt
+      path.join(HOME, '.vscode-server', 'extensions'),                                  // remote / SSH
     ],
     systemSignalFilter: (signalPath) => {
+      // Only return true if a github.copilot extension folder exists inside
       try {
         const entries = fs.readdirSync(signalPath)
         return entries.some(e => e.toLowerCase().startsWith('github.copilot'))
@@ -81,7 +86,7 @@ export const AGENTS = {
     },
     projectSignals: ['.github/copilot-instructions.md'],
     projectInstallDir: '.github',
-    globalInstallDir: null,
+    globalInstallDir: null, // Copilot has no global rules path
     filename: 'copilot-instructions.md',
     configNote: 'Written to .github/copilot-instructions.md'
   },
@@ -93,10 +98,19 @@ export const AGENTS = {
     projectInstallDir: '.enet',
     globalInstallDir: null,
     filename: '{id}.md',
-    configNote: "Saved to .enet/ — paste contents into your agent's context"
+    configNote: 'Saved to .enet/ — paste contents into your agent\'s context'
   }
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Detection
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Detects ALL agents installed on the system by checking known global paths.
+ * Uses systemSignalFilter for agents that share directories with other software
+ * (e.g. Copilot shares VS Code's extensions folder).
+ */
 export async function detectSystemAgents() {
   const found = []
   for (const [key, agent] of Object.entries(AGENTS)) {
@@ -109,7 +123,7 @@ export async function detectSystemAgents() {
           found.push({ key, ...agent })
           break
         }
-        continue
+        continue // signal dir exists but filter didn't match — try next signal path
       }
       found.push({ key, ...agent })
       break
@@ -118,6 +132,9 @@ export async function detectSystemAgents() {
   return found
 }
 
+/**
+ * Detects ALL agents present in the current project folder.
+ */
 export async function detectProjectAgents(cwd = process.cwd()) {
   const found = []
   for (const [key, agent] of Object.entries(AGENTS)) {
@@ -132,16 +149,33 @@ export async function detectProjectAgents(cwd = process.cwd()) {
   return found
 }
 
+/**
+ * Returns the first detected agent (legacy — used by status/doctor).
+ */
 export async function detectAgent(cwd = process.cwd()) {
   const agents = await detectProjectAgents(cwd)
   return agents[0] ?? { key: 'generic', ...AGENTS.generic }
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Path resolution
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Returns the resolved install path for a given agent + method.
+ *
+ * Special cases:
+ *  - antigravity global → ~/.gemini/antigravity/skills/method-{id}/SKILL.md
+ *    Each method gets its own subfolder (not a shared file).
+ *  - windsurf global    → ~/.codeium/windsurf/memories/global_rules.md
+ *  - claudecode global  → ~/.claude/CLAUDE.md
+ */
 export function getInstallPath(agent, methodId, { global = false, cwd = process.cwd() } = {}) {
   if (global) {
-    if (!agent.globalInstallDir) return null
+    if (!agent.globalInstallDir) return null // agent doesn't support global install
 
     if (agent.key === 'antigravity') {
+      // Dynamic subfolder per method: skills/method-{id}/SKILL.md
       return path.join(agent.globalInstallDir, `method-${methodId}`, 'SKILL.md')
     }
 
@@ -149,6 +183,7 @@ export function getInstallPath(agent, methodId, { global = false, cwd = process.
     return path.join(agent.globalInstallDir, filename)
   }
 
+  // Project-level install
   const filename = agent.filename.replace('{id}', methodId)
   return path.join(cwd, agent.projectInstallDir, filename)
 }

package/src/utils/registry.js

@@ -4,62 +4,40 @@ import path from 'path'
 import { fileURLToPath } from 'url'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const RAW_BASE   = 'https://raw.githubusercontent.com'
+const RAW_BASE     = 'https://raw.githubusercontent.com'
 const REGISTRY_URL = `${RAW_BASE}/exchanet/enet/main/registry.json`
 const CACHE_FILE   = path.join(__dirname, '../../.registry-cache.json')
 const CACHE_TTL_MS = 1000 * 60 * 60 // 1 hour
 
 // ── Registry ──────────────────────────────────────────────────────────────────
 
-/**
- * Loads the registry from:
- * 1. Remote GitHub (exchanet/enet/registry.json) — always fresh
- * 2. Local cache if remote fails — fallback
- * 3. Bundled registry.json in the package — last resort
- */
 export async function loadRegistry() {
-  // Try remote first
   try {
     const res = await fetch(REGISTRY_URL, { timeout: 5000 })
     if (res.ok) {
       const data = await res.json()
-      // Save to cache for offline fallback
       await fs.writeJson(CACHE_FILE, { ...data, _cachedAt: Date.now() }).catch(() => {})
       return data
     }
-  } catch {
-    // Network unavailable — fall through to cache
-  }
+  } catch { /* network unavailable */ }
 
-  // Try local cache
   try {
     if (await fs.pathExists(CACHE_FILE)) {
       const cached = await fs.readJson(CACHE_FILE)
       const age = Date.now() - (cached._cachedAt || 0)
-      if (age < CACHE_TTL_MS * 24) { // Accept cache up to 24h when offline
-        return cached
-      }
+      if (age < CACHE_TTL_MS * 24) return cached
     }
-  } catch {
-    // Cache corrupted — fall through to bundled
-  }
+  } catch { /* cache corrupted */ }
 
-  // Fallback to bundled registry.json
   const bundled = path.join(__dirname, '../../registry.json')
   return fs.readJson(bundled)
 }
 
-/**
- * Returns a single method from the registry, or null if not found.
- */
 export async function getMethod(id) {
   const registry = await loadRegistry()
   return registry.methods?.[id] ?? null
 }
 
-/**
- * Returns all methods from the registry as an array.
- */
 export async function getAllMethods() {
   const registry = await loadRegistry()
   return Object.values(registry.methods ?? {})
@@ -67,19 +45,69 @@ export async function getAllMethods() {
 
 // ── GitHub file fetcher ───────────────────────────────────────────────────────
 
-/**
- * Fetches a raw file from a GitHub repo (main branch).
- */
 export async function fetchFromGitHub(repo, filePath) {
   const url = `${RAW_BASE}/${repo}/main/${filePath}`
   const res = await fetch(url)
-
   if (!res.ok) {
     throw new Error(
       `Could not fetch ${filePath} from ${repo} (HTTP ${res.status})\n` +
       `  URL: ${url}`
     )
   }
-
   return res.text()
 }
+
+// ── Install state ─────────────────────────────────────────────────────────────
+//
+// Tracks which agents have each method installed.
+// Stored in <project>/.enet/installed.json
+//
+// Format:
+// {
+//   "pdca-t": {
+//     "agents": ["cursor", "claudecode", "antigravity"],
+//     "version": "3.0.0",
+//     "updatedAt": "2025-03-01T10:00:00.000Z"
+//   }
+// }
+
+function getInstallRecordFile() {
+  return path.join(process.cwd(), '.enet', 'installed.json')
+}
+
+/**
+ * Returns the install record for a single method, or null if never installed.
+ */
+export async function readInstallRecord(methodId) {
+  try {
+    const file = getInstallRecordFile()
+    if (!await fs.pathExists(file)) return null
+    const data = await fs.readJson(file)
+    return data[methodId] ?? null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Writes the install record for a single method.
+ * Merges with existing records — other methods are never touched.
+ */
+export async function writeInstallRecord(methodId, record) {
+  try {
+    const file = getInstallRecordFile()
+    await fs.ensureDir(path.dirname(file))
+    let data = {}
+    if (await fs.pathExists(file)) {
+      data = await fs.readJson(file).catch(() => ({}))
+    }
+    data[methodId] = {
+      agents:    record.agents,
+      version:   record.version ?? null,
+      updatedAt: new Date().toISOString()
+    }
+    await fs.writeJson(file, data, { spaces: 2 })
+  } catch {
+    // Non-fatal — install works correctly even if state cannot be saved
+  }
+}