@exchanet/enet 1.0.8 → 1.0.10

package/.enet/pdca-t.md

@@ -0,0 +1,110 @@
+---
+description: Method PDCA-T — Systematic quality cycle for AI-assisted coding
+trigger: always_on
+---
+
+# METHOD PDCA-T — Active for all tasks in this project
+
+You are operating under the PDCA-T quality methodology. Apply this 8-phase cycle to every coding task without exception.
+
+## PHASE 1 — PLANNING
+Before writing any code:
+- State the exact objective in one sentence
+- Define what IS and IS NOT in scope
+- Ask clarifying questions if anything is ambiguous
+- Identify external dependencies
+- Define the acceptance criterion
+
+Do not advance until the objective is unambiguous.
+
+## PHASE 2 — REQUIREMENTS ANALYSIS
+- List Functional Requirements: `FR-NN: [what the system must do]`
+- List Non-Functional Requirements: `NFR-NN: [constraint or quality attribute with metric]`
+- Build Risk Register: `RISK-NN: [risk] | Probability | Impact | Mitigation`
+
+## PHASE 3 — ARCHITECTURE DESIGN
+Before any implementation:
+- Write ADRs: `ADR-NN: [title] | Context | Decision | Alternatives | Consequences`
+- Define interface contracts (function signatures + full docstrings) before implementing bodies
+- Define module structure: domain / infrastructure / interfaces
+
+## PHASE 4 — MICRO-TASK CYCLE (≤ 50 lines per task)
+
+**4.1** — Check available skills in `.cursor/skills/` and reusable context
+
+**4.2** — Write tests FIRST. Required categories:
+- Happy path · Error cases · Edge cases · Security · Performance (if applicable)
+- Structure: Arrange / Act / Assert
+- Naming: `test_[function]_[scenario]_[expected_outcome]`
+
+**4.3** — Implement code. Standards:
+- Full type hints on every parameter and return value
+- Docstring with Args, Returns, Raises
+- Single responsibility per function
+- `Decimal` not `float` for monetary values
+- Specific exception types — never bare `except:`
+- Zero hardcoded configuration
+- Structured logging with context fields
+
+**4.4** — Self-review before running tests:
+```
+□ Type hints complete?        □ All inputs validated?
+□ Docstring written?          □ No hardcoded secrets?
+□ Single responsibility?      □ Semantic names?
+□ No code duplication?        □ Errors logged with context?
+```
+
+**4.5** — Execute tests and show REAL complete output:
+```bash
+pytest tests/ -v --cov=src --cov-report=term-missing --tb=short
+```
+Never summarize. Never say "tests pass". Show the exact output.
+
+**4.6** — Validate:
+- All tests pass (100%)? If not → fix code, explain, re-run
+- Coverage ≥ 99%? If not → identify uncovered lines → add tests → re-run
+- Repeat until both conditions are met
+
+## PHASE 5 — INTEGRAL VALIDATION
+After all micro-tasks:
+- **Security:** No OWASP Top 10 issues · inputs validated · outputs sanitized · no hardcoded secrets · minimum privilege
+- **Tests:** 100% passed · 0 failed · coverage ≥ 99% · all categories present
+- **Code quality:** Type hints 100% · cyclomatic complexity < 10 · no duplication · SRP · docstrings 100%
+- **Performance:** No N+1 · indexes on filter fields · pagination in collections · timeouts configured
+- **Architecture:** No circular imports · layers respected · low coupling · inward dependencies only
+
+## PHASE 6 — TECHNICAL DEBT MANAGEMENT
+Register every known issue before delivery:
+```
+DEBT-XXX: [Short title]
+  Type: Technical | Test | Documentation | Architecture | Security | Performance
+  Description: [What and why]
+  Impact: High | Medium | Low — [justification]
+  Effort: Xh
+  Priority: High | Medium | Low
+  Plan: [Specific action and target version]
+```
+Do not write TODO/FIXME in code — register as DEBT-XXX instead.
+
+## PHASE 7 — REFINEMENT TO ≥ 99%
+If any metric is below target:
+`Identify → Classify → Plan → Execute → Verify → Confirm ≥ 99%`
+Never advance to Phase 8 without confirming ≥ 99% on all 5 validation dimensions.
+
+## PHASE 8 — DELIVERY REPORT
+Always close every task with:
+1. Implementation summary (2-3 sentences)
+2. Test table: total / passed / failed / coverage / time
+3. Full unedited pytest output
+4. Key technical decisions with justifications
+5. Technical debt registered (DEBT-XXX list)
+6. CI/CD checklist (all items confirmed)
+7. Suggested next steps
+
+## ABSOLUTE RULES — NEVER VIOLATE
+1. Tests BEFORE implementation — always, no exceptions
+2. Show REAL test output — never summarize or omit
+3. No hardcoded secrets — environment variables from commit 1
+4. Coverage ≥ 99% before any delivery
+5. ADRs for non-trivial decisions
+6. All known issues as DEBT-XXX with priority and plan

package/package.json

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

package/src/commands/install.js

@@ -2,26 +2,35 @@ import chalk from 'chalk'
 import ora from 'ora'
 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'
 
 export async function installCommand(methodId, options) {
-  // Load method from registry
+  // 1. Load method from registry
   const spinner = ora('Fetching registry...').start()
   const method = await getMethod(methodId).catch(() => null)
   spinner.stop()
 
   if (!method) {
-    console.log(chalk.red(`  ✗ Unknown method: "${methodId}"`))
+    console.log(chalk.red(`\n  ✗ Unknown method: "${methodId}"`))
     console.log(chalk.dim(`  Run ${chalk.white('enet list')} to see available methods.\n`))
     process.exit(1)
   }
 
-  // Determine target agents
+  console.log(chalk.bold(`\n  ◆ ${method.name}`))
+  console.log(chalk.dim(`  ${method.description}\n`))
+    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`))
+    }
+
+  // 2. Determine target agents
   let targetAgents = []
 
   if (options.agent) {
-    // --agent flag: install for a specific agent only
+    // --agent flag: skip detection, install for this specific agent only
     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`))
@@ -36,57 +45,147 @@ export async function installCommand(methodId, options) {
     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(`  Valid: cursor, windsurf, antigravity, claudecode, copilot, generic\n`))
+      console.log(chalk.dim(`  Valid: ${Object.keys(AGENTS).filter(k => k !== 'generic').join(', ')}\n`))
       process.exit(1)
     }
 
-    if (detected.length === 1 || options.global) {
-      // Only one detected, or --global flag: install for all without asking
+    // 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 {
-      // Multiple agents detected: ask the user
-      console.log(chalk.white(`\n  Detected ${detected.length} agents on this system:\n`))
-      detected.forEach((a, i) => console.log(chalk.dim(`  [${i + 1}] ${a.name}`)))
-      console.log(chalk.dim(`  [${detected.length + 1}] All of the above\n`))
-
-      const { createInterface } = await import('readline')
-      const rl = createInterface({ input: process.stdin, output: process.stdout })
-      const answer = await new Promise(resolve => {
-        rl.question(chalk.white('  Install for which agent(s)? '), resolve)
-      })
-      rl.close()
+      targetAgents = await checkboxSelect(detected, method)
+    }
 
-      const choice = parseInt(answer.trim())
-      if (choice === detected.length + 1) {
-        targetAgents = detected
-      } else if (choice >= 1 && choice <= detected.length) {
-        targetAgents = [detected[choice - 1]]
-      } else {
-        console.log(chalk.red('\n  Invalid choice. Cancelled.\n'))
-        process.exit(1)
-      }
+    if (targetAgents.length === 0) {
+      console.log(chalk.dim('\n  Nothing selected. Cancelled.\n'))
+      process.exit(0)
     }
   }
 
   console.log()
 
-  // Install for each target agent
+  // 4. Install for each selected agent
   let schemaInstalled = false
   for (const agent of targetAgents) {
     await installForAgent(method, agent, options, schemaInstalled)
-    schemaInstalled = true // only install schema once
+    schemaInstalled = true
   }
 
   printHints(methodId)
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Checkbox selection UI
+// ─────────────────────────────────────────────────────────────────
+
+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'])
+  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`))
+    process.exit(1)
+  }
+
+  // Initial state: all available agents pre-checked
+  const items = available.map(a => ({
+    agent: a,
+    checked: true,
+    usesGeneric: !method.adapters[a.key]
+  }))
+
+  console.log(chalk.white('  Agents detected on your system:\n'))
+
+  return new Promise((resolve) => {
+    let cursor = 0
+
+    const render = () => {
+      // Move cursor up to redraw (after first render)
+      const lines = items.length + 6
+      if (render.drawn) process.stdout.write(`\x1B[${lines}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`)
+      })
+
+      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('  ↑↓ navigate · Space toggle · A select all · Enter confirm\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') {                      // arrow up
+        cursor = (cursor - 1 + items.length) % items.length
+        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
+        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`))
+        resolve(selected)
+      } else if (k === '\u0003') {                 // Ctrl+C
+        if (process.stdin.isTTY) process.stdin.setRawMode(false)
+        process.stdin.pause()
+        rl.close()
+        console.log('\n')
+        process.exit(0)
+      }
+    })
+  })
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Install for one agent
+// ─────────────────────────────────────────────────────────────────
+
 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'
   const adapterPath = method.adapters[adapterKey]
 
+  if (!adapterPath) {
+    console.log(chalk.yellow(`  ⚠ ${agent.name} — no adapter found, skipping`))
+    return
+  }
+
   if (isGlobal && !agent.globalInstallDir) {
-    console.log(chalk.yellow(`  ⚠ ${agent.name} does not support global install — skipping`))
+    console.log(chalk.yellow(`  ⚠ ${agent.name} — global install not supported, skipping`))
     return
   }
 
@@ -98,7 +197,7 @@ async function installForAgent(method, agent, options, skipExtras = false) {
 
     await fs.ensureDir(path.dirname(installPath))
 
-    // Windsurf global appends to global_rules.md
+    // Windsurf: append to .windsurfrules instead of overwriting
     if (agent.key === 'windsurf' && await fs.pathExists(installPath)) {
       const existing = await fs.readFile(installPath, 'utf8')
       if (existing.includes(method.name)) {
@@ -110,7 +209,7 @@ async function installForAgent(method, agent, options, skipExtras = false) {
       await fs.writeFile(installPath, content)
     }
 
-    spinner.succeed(chalk.green(`${agent.name} — installed`))
+    spinner.succeed(chalk.green(`${agent.name}`))
     console.log(chalk.dim(`  → ${installPath}`))
     console.log(chalk.dim(`  ${agent.configNote}\n`))
 
@@ -119,7 +218,7 @@ async function installForAgent(method, agent, options, skipExtras = false) {
     return
   }
 
-  // Download extras (schema, etc.) once
+  // Download extras (schema, etc.) — only once across all agents
   if (!skipExtras && method.extras) {
     for (const [key, filePath] of Object.entries(method.extras)) {
       const extraSpinner = ora(`Fetching ${key}...`).start()
@@ -136,18 +235,26 @@ async function installForAgent(method, agent, options, skipExtras = false) {
   }
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Post-install hints
+// ─────────────────────────────────────────────────────────────────
+
 function printHints(methodId) {
   if (methodId === 'modular-design') {
-    console.log(chalk.dim('  Next:'))
-    console.log(chalk.dim(`  1. Give your agent a spectech (stack + modules needed)`))
-    console.log(chalk.dim(`  2. Agent declares architecture — confirm it`))
-    console.log(chalk.dim(`  3. Agent builds Core → modules → Admin Panel`))
+    console.log(chalk.dim('  Next steps:'))
+    console.log(chalk.dim('  1. Give your agent a spectech (stack + modules needed)'))
+    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 validate')}             check manifests at any time\n`))
   }
   if (methodId === 'pdca-t') {
-    console.log(chalk.dim(`  PDCA-T adds quality validation to your workflow.`))
+    console.log(chalk.dim('  Next steps:'))
+    console.log(chalk.dim('  1. Start any coding task — the method activates automatically'))
+    console.log(chalk.dim('  2. Your agent will follow the 8-phase quality cycle'))
+    console.log(chalk.dim('  3. Every delivery includes a full test report'))
+    console.log()
     console.log(chalk.dim(`  Works best alongside ${chalk.white('enet install modular-design')}.\n`))
   }
 }

package/src/commands/update.js

@@ -1,12 +1,15 @@
 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, 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 +21,203 @@ 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}`))
+    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 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) }
+      }
+
+      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`))
     }
   }
 
+  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`))
+}
+
+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 { fetchFromGitHub } = await import('../utils/registry.js')
+    const content = await fetchFromGitHub(method.repo, adapterPath)
+    await fs.ensureDir(path.dirname(installPath))
+
+    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
   }
 }
+
+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 tag   = item.usesGeneric ? chalk.dim(' (generic adapter)') : ''
+        process.stdout.write(`${arrow}${box} ${name}${tag}\n`)
+      })
+      process.stdout.write('\n')
+      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A all · Enter confirm\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)
+      }
+    })
+  })
+}
+```
+
+---
+
+## Dónde van estos archivos en el repo
+```
+exchanet/enet/
+├── src/
+│   ├── commands/
+│   │   ├── install.js   ← cambios A, B, C + checkboxSelect con alreadyInstalled
+│   │   └── update.js    ← reemplazar completo
+│   └── utils/
+│       └── registry.js  ← añadir al final las 2 funciones nuevas
+```
+
+Una vez subidos, el flujo queda así:
+```
+$ enet install pdca-t        # primera vez
+  Already installed for: copilot   ← lee .enet/installed.json
+
+  Select adapters to install:
+   ❯ [✓] Cursor              — new
+     [✓] Antigravity          — new
+     [✓] Claude Code          — new
+     [✓] GitHub Copilot       — installed   ← sabe que ya está
+
+$ enet update pdca-t         # después de instalar Windsurf
+  Method PDCA-T
+  Installed for: cursor, claudecode
+
+  Updating Cursor...          ✓  ← re-descarga adapter
+  Updating Claude Code...     ✓
+
+  New agents detected since last install:
+   ❯ [✓] Windsurf             — new
+
+  → instala Windsurf y actualiza installed.json

package/src/utils/agent-detector.js

@@ -8,7 +8,10 @@ export const AGENTS = {
   cursor: {
     name: 'Cursor',
     systemSignals: [
-      path.join(HOME, '.cursor')
+      path.join(HOME, '.cursor'),
+      path.join(HOME, 'Library', 'Application Support', 'Cursor'),
+      path.join(HOME, 'AppData', 'Roaming', 'Cursor'),
+      path.join(HOME, '.config', 'Cursor'),
     ],
     projectSignals: ['.cursor/rules', '.cursor'],
     projectInstallDir: '.cursor/rules',
@@ -16,82 +19,105 @@ export const AGENTS = {
     filename: 'enet-{id}.md',
     configNote: 'Rule auto-applies to all files (alwaysApply: true)'
   },
+
   windsurf: {
     name: 'Windsurf',
     systemSignals: [
-      path.join(HOME, '.codeium', 'windsurf')
+      path.join(HOME, '.codeium', 'windsurf'),
+      path.join(HOME, 'Library', 'Application Support', 'Windsurf'),
+      path.join(HOME, 'AppData', 'Roaming', 'Windsurf'),
     ],
     projectSignals: ['.windsurfrules', '.windsurf'],
     projectInstallDir: '.',
     globalInstallDir: path.join(HOME, '.codeium', 'windsurf', 'memories'),
     globalFilename: 'global_rules.md',
     filename: '.windsurfrules',
-    configNote: 'Appended to global_rules.md'
+    configNote: 'Appended to .windsurfrules in project root'
   },
+
   antigravity: {
     name: 'Antigravity (Google)',
     systemSignals: [
-      path.join(HOME, '.gemini', 'antigravity')
+      path.join(HOME, '.gemini', 'antigravity'),
+      path.join(HOME, 'Library', 'Application Support', 'Google', 'Antigravity'),
+      path.join(HOME, 'AppData', 'Roaming', 'Google', 'Antigravity'),
     ],
     projectSignals: ['.agent/rules', '.agent'],
     projectInstallDir: '.agent/rules',
-    globalInstallDir: path.join(HOME, '.gemini', 'antigravity', 'skills', 'method-modular-design'),
+    globalInstallDir: path.join(HOME, '.gemini', 'antigravity', 'skills'),
     globalFilename: 'SKILL.md',
     filename: 'enet-{id}.md',
-    configNote: 'Skill saved — set activation to Always On in Antigravity'
+    configNote: 'Rule placed in .agent/rules/ — activates automatically in Antigravity'
   },
+
   claudecode: {
     name: 'Claude Code',
     systemSignals: [
-      path.join(HOME, '.claude')
+      path.join(HOME, '.claude'),
     ],
     projectSignals: ['CLAUDE.md', '.claude'],
     projectInstallDir: '.',
     globalInstallDir: path.join(HOME, '.claude'),
     globalFilename: 'CLAUDE.md',
     filename: 'CLAUDE.md',
-    configNote: 'Written to ~/.claude/CLAUDE.md — Claude Code reads this automatically'
+    configNote: 'Written to CLAUDE.md — Claude Code reads this automatically'
   },
+
   copilot: {
     name: 'GitHub Copilot',
-    systemSignals: [],
+    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'),
+    ],
+    systemSignalFilter: (signalPath) => {
+      try {
+        const entries = fs.readdirSync(signalPath)
+        return entries.some(e => e.toLowerCase().startsWith('github.copilot'))
+      } catch {
+        return false
+      }
+    },
     projectSignals: ['.github/copilot-instructions.md'],
     projectInstallDir: '.github',
     globalInstallDir: null,
     filename: 'copilot-instructions.md',
     configNote: 'Written to .github/copilot-instructions.md'
   },
+
   generic: {
-    name: 'Generic Agent',
+    name: 'Generic / Other agent',
     systemSignals: [],
     projectSignals: [],
     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"
   }
 }
 
-/**
- * Detects ALL agents installed on the system by checking known global paths.
- */
 export async function detectSystemAgents() {
   const found = []
   for (const [key, agent] of Object.entries(AGENTS)) {
     if (key === 'generic') continue
     for (const signal of agent.systemSignals) {
-      if (await fs.pathExists(signal)) {
-        found.push({ key, ...agent })
-        break
+      const exists = await fs.pathExists(signal)
+      if (!exists) continue
+      if (agent.systemSignalFilter) {
+        if (agent.systemSignalFilter(signal)) {
+          found.push({ key, ...agent })
+          break
+        }
+        continue
       }
+      found.push({ key, ...agent })
+      break
     }
   }
   return found
 }
 
-/**
- * Detects ALL agents present in the current project.
- */
 export async function detectProjectAgents(cwd = process.cwd()) {
   const found = []
   for (const [key, agent] of Object.entries(AGENTS)) {
@@ -106,22 +132,23 @@ 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 }
 }
 
-/**
- * Returns the install path for a method adapter.
- */
 export function getInstallPath(agent, methodId, { global = false, cwd = process.cwd() } = {}) {
   if (global) {
+    if (!agent.globalInstallDir) return null
+
+    if (agent.key === 'antigravity') {
+      return path.join(agent.globalInstallDir, `method-${methodId}`, 'SKILL.md')
+    }
+
     const filename = agent.globalFilename ?? agent.filename.replace('{id}', methodId)
     return path.join(agent.globalInstallDir, filename)
   }
+
   const filename = agent.filename.replace('{id}', methodId)
   return path.join(cwd, agent.projectInstallDir, filename)
 }

package/src/utils/registry.js

@@ -83,3 +83,31 @@ export async function fetchFromGitHub(repo, filePath) {
 
   return res.text()
 }
+
+// ── Install state ─────────────────────────────────────────────────────────────
+// Stored in <project>/.enet/installed.json
+// { "pdca-t": { "agents": ["cursor", "claudecode"], "version": "3.0.0", "updatedAt": "..." } }
+
+function getInstallRecordFile() {
+  return path.join(process.cwd(), '.enet', 'installed.json')
+}
+
+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 }
+}
+
+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 */ }
+}