@polderlabs/bizar 8.0.0 → 9.0.0

package/.claude/worktrees/kanban-overhaul/cli/plugin-runtime-deps.mjs

@@ -0,0 +1,250 @@
+/**
+ * cli/plugin-runtime-deps.mjs
+ *
+ * Shared helper for wiring the runtime deps (`zod`, `@cline/sdk`,
+ * `@cline/core`, `@cline/shared`) into a deployed plugin's
+ * `node_modules/`. Extracted out of `cli/provision.mjs` so that BOTH
+ * code paths can use it:
+ *
+ *   - `cli/provision.mjs:copyPluginToCline()` — used by `bizar install`
+ *     and `bizar update` (the "modern" provisioner).
+ *   - `cli/install.mjs:installPluginFromGlobal()` — used by
+ *     `runPostInstall()` and the auto-bootstrap on first `bizar` bin
+ *     invocation (the "legacy" path that `cli/install.mjs` exposes for
+ *     backward compat with the npm postinstall hook).
+ *
+ * The bug we're fixing: the legacy `installPluginFromGlobal` had its
+ * OWN copy of the wiring logic that only listed `@cline/*` peer deps,
+ * never `zod`. Result: after `npm install -g @polderlabs/bizar` +
+ * `bizar install`, the plugin loaded from `~/.config/cline/plugins/bizar/`
+ * threw `Cannot find module 'zod' (+2 more)` at startup. Both call
+ * sites now go through this single function so the bug can't drift
+ * back in.
+ *
+ * Resolution order (first match wins):
+ *   1. The Bizar npm package's own `node_modules/`
+ *      (`<npm root -g>/@polderlabs/bizar/node_modules`).
+ *   2. The `cline` npm package's `node_modules/`
+ *      (`<npm root -g>/cline/node_modules`).
+ *   3. The dev source tree's `node_modules/`
+ *      (`<REPO_ROOT>/node_modules`).
+ *
+ * Symlinks are preferred (cheap, always-fresh). Falls back to a
+ * recursive copy on filesystems that don't support symlinks (e.g.
+ * Windows without developer mode).
+ *
+ * Best-effort: a missing dep is logged but never throws. Run
+ * `bizar doctor` to diagnose if any deps couldn't be wired.
+ */
+
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  symlinkSync,
+  unlinkSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Default runtime deps the Bizar plugin needs at load time.
+ *
+ * - `zod` is the schema-validation library the plugin uses for tool
+ *   input/output validation. It's listed in the plugin's
+ *   `package.json` as a regular `dependencies` entry, so it must be
+ *   resolvable from the deployed plugin's `node_modules/`.
+ * - `@cline/*` are peer deps that the host `cline` runtime provides
+ *   (and that the Bizar npm pkg also bundles for dev convenience).
+ */
+export const DEFAULT_RUNTIME_DEPS = Object.freeze([
+  { name: 'zod', scope: null },
+  { name: 'sdk', scope: '@cline' },
+  { name: 'core', scope: '@cline' },
+  { name: 'shared', scope: '@cline' },
+]);
+
+/**
+ * Discover candidate `node_modules/` roots to search for runtime deps.
+ *
+ * Each entry is a directory path. Order matters — earlier roots win
+ * when a dep exists in multiple places.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.pkgRoot] - Path to the Bizar npm package
+ *   (e.g. `<npm root -g>/@polderlabs/bizar`). When omitted we try
+ *   `npm root -g` to find it.
+ * @param {string} [opts.repoRoot] - Path to the dev source tree. When
+ *   omitted we derive it from this file's location.
+ * @returns {string[]} Absolute paths to candidate `node_modules/` dirs.
+ */
+export function findRuntimeDepRoots({ pkgRoot, repoRoot, clineRoot } = {}) {
+  const roots = [];
+
+  // 1. Bizar npm package's own node_modules.
+  //    If `pkgRoot` is supplied, use it directly (no auto-discovery).
+  //    Otherwise try `npm root -g`.
+  if (pkgRoot) {
+    const nm = join(pkgRoot, 'node_modules');
+    if (existsSync(nm)) roots.push(nm);
+  } else {
+    try {
+      const npmRoot = execSync('npm root -g', { encoding: 'utf8', timeout: 5000 }).trim();
+      const candidate = join(npmRoot, '@polderlabs', 'bizar');
+      if (existsSync(candidate)) {
+        const nm = join(candidate, 'node_modules');
+        if (existsSync(nm)) roots.push(nm);
+      }
+    } catch {
+      // ignore — best-effort
+    }
+  }
+
+  // 2. The `cline` npm package's bundled node_modules.
+  //    If `clineRoot` is supplied, use it directly. Otherwise try
+  //    `npm root -g` to find the active cline install.
+  if (clineRoot) {
+    const nm = join(clineRoot, 'node_modules');
+    if (existsSync(nm)) roots.push(nm);
+  } else if (!pkgRoot) {
+    // Only auto-discover cline when pkgRoot was not provided.
+    // When pkgRoot is provided, the caller is driving the test
+    // explicitly and we should not silently fall through to the
+    // real system install.
+    try {
+      const npmRoot = execSync('npm root -g', { encoding: 'utf8', timeout: 5000 }).trim();
+      const clineNm = join(npmRoot, 'cline', 'node_modules');
+      if (existsSync(clineNm)) roots.push(clineNm);
+    } catch {
+      // ignore — best-effort
+    }
+  }
+
+  // 3. The dev source tree's node_modules.
+  if (repoRoot) {
+    const nm = join(repoRoot, 'node_modules');
+    if (existsSync(nm)) roots.push(nm);
+  } else {
+    const resolvedRepoRoot = join(__dirname, '..');
+    const repoNm = join(resolvedRepoRoot, 'node_modules');
+    if (existsSync(repoNm)) roots.push(repoNm);
+  }
+
+  return roots;
+}
+
+/**
+ * Wire runtime-only deps into the deployed plugin's `node_modules/`.
+ *
+ * Bun's module resolver walks up from the plugin entry point looking
+ * for `node_modules/`, and without an entry in `${dest}/node_modules/`,
+ * the plugin fails to load with `Cannot find module 'zod' (+2 more)`.
+ *
+ * Strategy: for each dep, find the first candidate root that has it
+ * and symlink (preferred) or copy (fallback) it into
+ * `${dest}/node_modules/<scope>/<name>`.
+ *
+ * Already-wired deps are skipped (idempotent). A missing dep is
+ * recorded in `missing` but never throws.
+ *
+ * @param {string} dest - Deployed plugin directory (must already exist).
+ * @param {Array<{name: string, scope: string | null}>} [deps]
+ *   Each entry is `{ name, scope }`. `scope` is null for unscoped
+ *   packages (e.g. `zod`) or `@<scope>` for scoped (e.g. `@cline`).
+ *   Defaults to {@link DEFAULT_RUNTIME_DEPS}.
+ * @param {object} [opts]
+ * @param {string} [opts.pkgRoot] - Bizar npm pkg root (see
+ *   {@link findRuntimeDepRoots}).
+ * @param {string} [opts.repoRoot] - Dev source tree root.
+ * @param {boolean} [opts.silent] - Suppress the "wired N deps" log.
+ * @returns {Promise<{wired: string[], missing: string[]}>}
+ */
+export async function wirePluginRuntimeDeps(
+  dest,
+  deps = DEFAULT_RUNTIME_DEPS,
+  opts = {},
+) {
+  const { silent = false } = opts;
+  const wired = [];
+  const missing = [];
+  const candidateRoots = findRuntimeDepRoots({
+    pkgRoot: opts.pkgRoot,
+    repoRoot: opts.repoRoot,
+    clineRoot: opts.clineRoot,
+  });
+
+  for (const dep of deps) {
+    const rel = dep.scope ? join(dep.scope, dep.name) : dep.name;
+    const target = join(dest, 'node_modules', rel);
+
+    // If the symlink/dir already exists and is healthy, leave it.
+    try {
+      const st = lstatSync(target);
+      if (st.isSymbolicLink() || st.isDirectory()) {
+        wired.push(rel);
+        continue;
+      }
+      // Stale file (not a symlink/dir). Remove and re-create.
+      unlinkSync(target);
+    } catch {
+      // missing — fine
+    }
+
+    // Find the first candidate root that has this dep.
+    let source = null;
+    for (const root of candidateRoots) {
+      const candidate = join(root, rel);
+      if (existsSync(candidate)) {
+        source = candidate;
+        break;
+      }
+    }
+    if (!source) {
+      missing.push(rel);
+      continue;
+    }
+
+    // Make sure the parent dir exists.
+    mkdirSync(dirname(target), { recursive: true });
+
+    // Prefer symlink. Fall back to copy on EEXIST/EPERM.
+    try {
+      symlinkSync(source, target, 'dir');
+      wired.push(rel);
+    } catch (err) {
+      try {
+        const { cp } = await import('node:fs/promises');
+        await cp(source, target, { recursive: true });
+        wired.push(rel);
+      } catch (copyErr) {
+        missing.push(
+          `${rel} (symlink failed: ${err.code}; copy failed: ${copyErr.message})`,
+        );
+      }
+    }
+  }
+
+  if (missing.length > 0) {
+    console.warn(
+      chalk.yellow(
+        `  ⚠ Plugin runtime deps could not be wired: ${missing.join(', ')}. ` +
+        `Run \`bizar doctor\` to diagnose.`,
+      ),
+    );
+  }
+  if (wired.length > 0 && !silent) {
+    console.log(
+      chalk.green(
+        `  ✓ wired ${wired.length} plugin runtime ` +
+        `dep${wired.length === 1 ? '' : 's'}: ${wired.join(', ')}`,
+      ),
+    );
+  }
+  return { wired, missing };
+}
+

package/.claude/worktrees/kanban-overhaul/cli/post-install-smoke.mjs

@@ -0,0 +1,256 @@
+/**
+ * cli/post-install-smoke.mjs
+ *
+ * v5.x — Post-install smoke test for BizarHarness.
+ *
+ * Verifies the installation is functional by checking:
+ *   1. Memory vault exists and is git-initialized
+ *   2. `bizar doctor` exits 0
+ *   3. Dashboard HTTP responds 200
+ *   4. WebSocket connects to dashboard
+ *   5. `bizar bg list` returns (even if empty)
+ *   6. lightrag-server installed
+ *
+ * Each check has a 30s timeout. Exits 0 if all pass, 1 otherwise.
+ *
+ * Public API:
+ *   runSmokeTest({ bizarHome, repoPath })
+ *     → Promise<{ ok: boolean, checks: CheckResult[] }>
+ *
+ *   CheckResult: { name: string, ok: boolean, message: string }
+ */
+
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+const HOME = homedir();
+const DEFAULT_BIZAR_HOME = join(HOME, '.config', 'bizar');
+const DEFAULT_MEMORY_VAULT = join(HOME, '.bizar_memory');
+const DEFAULT_DASHBOARD_PORT = 4097;
+
+/**
+ * @param {object} opts
+ * @param {string} [opts.bizarHome]
+ * @param {string} [opts.repoPath]
+ * @param {number} [opts.timeoutMs]
+ */
+export async function runSmokeTest({ bizarHome, repoPath, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const bh = bizarHome || DEFAULT_BIZAR_HOME;
+  const mv = process.env.BIZAR_MEMORY_VAULT || DEFAULT_MEMORY_VAULT;
+  const port = parseInt(process.env.BIZAR_DASHBOARD_PORT || String(DEFAULT_DASHBOARD_PORT), 10) || DEFAULT_DASHBOARD_PORT;
+  const checks = [];
+
+  function check(name, fn) {
+    try {
+      const result = fn();
+      checks.push({ name, ok: result.ok, message: result.message || '' });
+    } catch (err) {
+      checks.push({ name, ok: false, message: err instanceof Error ? err.message : String(err) });
+    }
+  }
+
+  // ── 1. Memory vault exists and is git-initialised ───────────────────────
+  check('memory vault exists', () => {
+    if (!existsSync(mv)) {
+      return { ok: false, message: `${mv} does not exist` };
+    }
+    const gitDir = join(mv, '.git');
+    if (!existsSync(gitDir)) {
+      return { ok: false, message: `${mv} is not git-initialized (run: git init)` };
+    }
+    return { ok: true, message: `${mv} present and git-initialized` };
+  });
+
+  // ── 2. `bizar doctor` exits 0 ────────────────────────────────────────────
+  check('bizar doctor', () => {
+    try {
+      execSync('bizar doctor', {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: timeoutMs,
+        encoding: 'utf8',
+      });
+      return { ok: true, message: 'bizar doctor passed' };
+    } catch (err) {
+      const status = err.status;
+      const msg = err.stderr || err.message;
+      if (status === 0) return { ok: true, message: 'bizar doctor passed' };
+      return { ok: false, message: `bizar doctor failed (exit ${status}): ${msg}`.slice(0, 200) };
+    }
+  });
+
+  // ── 3. Dashboard HTTP responds 200 (with retry) ─────────────────────────────────
+  check('dashboard HTTP', async () => {
+    const maxAttempts = 5;
+    const delayMs = 2000;
+    let lastErr = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+          const res = await fetch(`http://127.0.0.1:${port}/`, {
+            signal: controller.signal,
+            method: 'GET',
+          });
+          clearTimeout(timer);
+          if (res.ok) {
+            if (attempt > 1) {
+              return { ok: true, message: `HTTP ${res.status} on port ${port} (tried ${attempt}x)` };
+            }
+            return { ok: true, message: `HTTP ${res.status} on port ${port}` };
+          }
+          lastErr = `HTTP ${res.status} on port ${port} (expected 200)`;
+        } catch (err) {
+          clearTimeout(timer);
+          lastErr = err.name === 'AbortError'
+            ? `dashboard not responding on port ${port} (timeout)`
+            : `dashboard unreachable on port ${port}: ${err.message}`;
+        }
+      } catch (err) {
+        lastErr = `fetch not available: ${err.message}`;
+      }
+      if (attempt < maxAttempts) {
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+    }
+    return { ok: false, message: lastErr || 'dashboard HTTP failed' };
+  });
+
+  // ── 4. WebSocket connects (with retry) ────────────────────────────────────────
+  check('dashboard WebSocket', async () => {
+    const maxAttempts = 5;
+    const delayMs = 2000;
+    let lastErr = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const { WebSocket } = await import('ws' in globalThis
+          ? { ws: globalThis.ws, WebSocket: globalThis.WebSocket }
+          : await import(`ws`).then(m => ({ ws: m, WebSocket: m.WebSocket || m.default }))
+        );
+        const url = `ws://127.0.0.1:${port}/ws`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+          const ws = new WebSocket(url);
+          await new Promise((resolve, reject) => {
+            ws.on('open', resolve);
+            ws.on('error', reject);
+            ws.on('close', () => reject(new Error('closed before open')));
+            controller.signal.addEventListener('abort', () => {
+              ws.close();
+              reject(new Error('timeout'));
+            });
+          });
+          clearTimeout(timer);
+          ws.close();
+          if (attempt > 1) {
+            return { ok: true, message: `WebSocket connected at ${url} (tried ${attempt}x)` };
+          }
+          return { ok: true, message: `WebSocket connected at ${url}` };
+        } catch (err) {
+          clearTimeout(timer);
+          lastErr = err.message === 'timeout'
+            ? `WebSocket timeout on ${url}`
+            : `WebSocket failed on ${url}: ${err.message}`;
+        }
+      } catch (err) {
+        // ws module not available in this environment — skip
+        if (err.code === 'MODULE_NOT_FOUND' || err.message?.includes('ws')) {
+          return { ok: true, message: 'ws module not available — skipping WebSocket check' };
+        }
+        lastErr = `WebSocket check failed: ${err.message}`;
+      }
+      if (attempt < maxAttempts) {
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+    }
+    return { ok: false, message: lastErr || 'WebSocket failed' };
+  });
+
+  // ── 5. `bizar bg list` returns ────────────────────────────────────────────
+  check('background agents', () => {
+    try {
+      execSync('bizar bg list', {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: timeoutMs,
+        encoding: 'utf8',
+      });
+      return { ok: true, message: 'bizar bg list succeeded' };
+    } catch (err) {
+      return { ok: false, message: `bizar bg list failed: ${(err.stderr || err.message || '').slice(0, 200)}` };
+    }
+  });
+
+  // ── 6. lightrag-server installed ─────────────────────────────────────────
+  // Just verify the binary exists — `lightrag-hku` (uv tool) does not
+  // reliably support --version across all versions, so we check file
+  // presence instead of running it.
+  check('lightrag-server', () => {
+    const localBin = join(HOME, '.local', 'bin', 'lightrag-server');
+    if (existsSync(localBin)) {
+      return { ok: true, message: `${localBin} exists` };
+    }
+    // Also check PATH via shell (covers shims installed by uv tool)
+    try {
+      const out = execSync('command -v lightrag-server', {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 5000,
+        encoding: 'utf8',
+      });
+      const resolved = (out || '').trim();
+      if (resolved) {
+        return { ok: true, message: `lightrag-server on PATH: ${resolved}` };
+      }
+    } catch { /* not on PATH */ }
+    return { ok: false, message: 'lightrag-server not found in PATH or ~/.local/bin/' };
+  });
+
+  // ── Summary ───────────────────────────────────────────────────────────────
+  const passed = checks.filter(c => c.ok).length;
+  const failed = checks.filter(c => !c.ok).length;
+  const allOk = failed === 0;
+
+  for (const c of checks) {
+    const marker = c.ok ? '✓' : '✗';
+    const msg = c.message ? `  ${marker} ${c.name}: ${c.message}` : `  ${marker} ${c.name}`;
+    if (c.ok) {
+      console.log(`\x1b[32m${msg}\x1b[0m`);
+    } else {
+      console.log(`\x1b[31m${msg}\x1b[0m`);
+    }
+  }
+
+  console.log(`\nSmoke test: ${passed} passed, ${failed} failed`);
+  return { ok: allOk, checks, passed, failed };
+}
+
+// ── CLI entry ─────────────────────────────────────────────────────────────────
+
+const isMain = Boolean(process.argv[1]) && process.argv[1].endsWith('post-install-smoke.mjs');
+if (isMain) {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const json = args.includes('--json');
+
+  if (dryRun) {
+    console.log('[dry-run] would run smoke test');
+    process.exit(0);
+  }
+
+  runSmokeTest().then(result => {
+    if (json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    }
+    process.exit(result.ok ? 0 : 1);
+  }).catch(err => {
+    if (json) {
+      console.error(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`Smoke test error: ${err.message}`);
+    }
+    process.exit(1);
+  });
+}

package/.claude/worktrees/kanban-overhaul/cli/prompts.mjs

@@ -0,0 +1,168 @@
+import inquirer from 'inquirer';
+
+const AGENTS_LIST = [
+  { name: 'Odin ᛟ  — MiniMax-M3 (Router)', value: 'odin.md', checked: true },
+  { name: 'Frigg ᚠ  — DeepSeek (Codebase Q&A, read-only)', value: 'frigg.md', checked: true },
+  { name: 'Vör ᚡ  — DeepSeek (Clarification)', value: 'vor.md', checked: true },
+  { name: 'Mimir ᛗ — DeepSeek (Research)', value: 'mimir.md', checked: true },
+  { name: 'Heimdall ᚹ — DeepSeek (Simple tasks)', value: 'heimdall.md', checked: true },
+  { name: 'Hermod ᚱ — MiniMax-M2.7 (Git ops)', value: 'hermod.md', checked: true },
+  { name: 'Thor ᚦ  — MiniMax-M2.7 (Mid impl.)', value: 'thor.md', checked: true },
+  { name: 'Baldr ᛒ  — MiniMax-M2.7 (Design)', value: 'baldr.md', checked: true },
+  { name: 'Tyr ᛏ  — MiniMax-M3 (Complex impl.)', value: 'tyr.md', checked: true },
+  { name: 'Vidarr ᛉ — MiniMax-M3 (Last resort)', value: 'vidarr.md', checked: false },
+  { name: 'Forseti ᚨ — MiniMax-M3 (Plan audit)', value: 'forseti.md', checked: true },
+];
+
+export async function promptComponents() {
+  const { components } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'components',
+    message: 'What would you like to install?',
+    choices: [
+      { name: 'Agent definitions (all 11 agents)', value: 'agents', checked: true },
+      { name: 'AGENTS.md routing table', value: 'agents-md', checked: true },
+      new inquirer.Separator(),
+      { name: 'BizarHarness skill', value: 'skill-bizar', checked: true },
+      { name: 'Self-improvement skill', value: 'skill-improve', checked: true },
+      { name: 'C++ coding standards skill', value: 'skill-cpp-std', checked: false },
+      { name: 'C++ testing skill', value: 'skill-cpp-test', checked: false },
+      { name: 'Embedded ESP-IDF skill', value: 'skill-esp-idf', checked: true },
+      new inquirer.Separator(),
+      { name: 'Always-on rules (5 rule files)', value: 'rules', checked: true },
+      { name: 'Hook system (behavioral hooks)', value: 'hooks', checked: true },
+      { name: 'Slash commands (/explain, /audit, /learn, /pr-review, /init)', value: 'commands', checked: true },
+      new inquirer.Separator(),
+      { name: 'cline.json (provider + MCP config)', value: 'cline-json', checked: true },
+      { name: '.bizar/ folder (self-improvement log)', value: 'bizar', checked: true },
+      new inquirer.Separator(),
+      { name: 'Bizar plugin (loop guard, status, handoff signal)', value: 'plugin-bizar', checked: true },
+    ],
+    pageSize: 18,
+    validate(answer) {
+      if (answer.length === 0) return 'Select at least one component.';
+      return true;
+    },
+  }]);
+  return components;
+}
+
+export async function promptInstallMode() {
+  const { mode } = await inquirer.prompt([{
+    type: 'list',
+    name: 'mode',
+    message: 'Installation mode:',
+    choices: [
+      { name: 'Fresh install  — overwrite existing config files', value: 'fresh' },
+      { name: 'Merge  — keep your existing config, add missing files only', value: 'merge' },
+    ],
+  }]);
+  return mode;
+}
+
+export async function promptAgents() {
+  const { agents } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'agents',
+    message: 'Select agents to install:',
+    choices: AGENTS_LIST,
+    pageSize: 12,
+    validate(answer) {
+      if (answer.length === 0) return 'Select at least one agent.';
+      return true;
+    },
+  }]);
+  return agents;
+}
+
+export async function promptApiKeys() {
+  const { setup } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setup',
+    message: 'Configure API keys now?',
+    default: false,
+  }]);
+  if (!setup) return {};
+
+  const keys = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'clineZen',
+      message: 'Cline Zen API key (DeepSeek V4 Flash Free):',
+      mask: '*',
+      validate: v => v.length > 0 || 'Required for free-tier agents (Mimir, Heimdall, Vör)',
+    },
+    {
+      type: 'password',
+      name: 'minimax',
+      message: 'MiniMax API key (M2.7 + M3):',
+      mask: '*',
+      validate: v => v.length > 0 || 'Required for Odin, Thor, Hermod, Baldr, Tyr, Forseti',
+    },
+    {
+      type: 'password',
+      name: 'openai',
+      message: 'OpenAI / cline-zen API key (optional — for non-default agents):',
+      mask: '*',
+    },
+    {
+      type: 'password',
+      name: 'obsidian_vault',
+      message: 'Obsidian vault path (memory persistence):',
+      mask: '*',
+      validate: v => v.length > 0 || 'Required for cross-session memory',
+    },
+    {
+      type: 'password',
+      name: 'semble',
+      message: 'Semble API key (code search — or leave blank for local only):',
+      mask: '*',
+    },
+  ]);
+  return keys;
+}
+
+export async function promptConfirmInstall(summary) {
+  const { ok } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'ok',
+    message: `Install ${summary.components} ${summary.agents} into ${summary.target}?`,
+    default: true,
+  }]);
+  return ok;
+}
+
+export async function promptRestartCline() {
+  const { restart } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'restart',
+    message: 'Restart cline now to pick up changes?',
+    default: true,
+  }]);
+  return restart;
+}
+
+export async function promptSkillPacks() {
+  const { usePacks } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'usePacks',
+    message: 'Install curated skills from skills.sh ecosystem? (find-skills, React, Supabase, TDD, design, etc.)',
+    default: true,
+  }]);
+  if (!usePacks) return [];
+
+  const { packs } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'packs',
+    message: 'Select skill packs to install:',
+    choices: [
+      { name: 'Core — find-skills, skill-creator, write-a-skill', value: 'core', checked: true },
+      { name: 'Frontend — React, web-design, composition, a11y, shadcn/ui', value: 'frontend', checked: false },
+      { name: 'Backend — Supabase, Postgres, API patterns, auth', value: 'backend', checked: false },
+      { name: 'Testing — TDD, E2E, Playwright, test patterns', value: 'testing', checked: false },
+      { name: 'Design — frontend-design, UI/UX, taste skills', value: 'design', checked: false },
+    ],
+    pageSize: 8,
+  }]);
+  return packs;
+}