@bahulam/code 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bahulam/code",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Bahulam Code — abundance, in your terminal. CLI-first, reliability-first, sub-agents, 65.6% SWE-bench Verified.",
   "type": "module",
   "bin": {

package/src/commands/install.mjs

@@ -40,6 +40,9 @@ const CYAN = '\x1b[36m';
 const GREEN = '\x1b[32m';
 const YELLOW = '\x1b[33m';
 
+const DEFAULT_BAHULAM_PLUGIN_REGISTRY_URL =
+  'https://raw.githubusercontent.com/BahulamAI/awesome-bahulam-plugins/main/registry.json';
+
 function parseArgs(argv) {
   const parsed = {
     source: null,
@@ -152,10 +155,13 @@ export async function handleInstallCommand(argv, { cwd = process.cwd() } = {}) {
 
   Install a pack. For pi sources, pulls the ingredient and scaffolds a
   full Bahulam pack (composition + state layer + workspace + agent), then
-  installs it. For git/tarball/local sources, installs the existing pack.
+  installs it. For registry/git/tarball/local sources, installs the
+  existing pack.
 
   Sources:
     pi:<npm-package>[@<version>]     Scaffold + install from a pi package
+    <registry-name>                  Install from awesome-bahulam-plugins
+    bahulam:<registry-name>          Explicit awesome-bahulam-plugins lookup
     <git-url>[.git]                  Clone a hand-authored pack
     <tarball-url>                    Download + install a pack tarball
     <local-path>                     Copy + install a local pack directory
@@ -166,7 +172,7 @@ export async function handleInstallCommand(argv, { cwd = process.cwd() } = {}) {
     --no-state             Skip the persistent state layer (pi sources only)
     --no-workspace         Skip the reactive workspace panel (pi sources only)
     --project              Install into ./.bahulam/plugins/ instead of ~/.bahulam/plugins/
-    --ref <ref>            Git branch/tag/commit (git sources only)
+    --ref <ref>            Git branch/tag/commit (git or registry sources)
     --json                 Machine-readable output
 
 `);
@@ -186,6 +192,12 @@ export async function handleInstallCommand(argv, { cwd = process.cwd() } = {}) {
       throw new Error(`unrecognized source: ${args.source}`);
     }
 
+    const registryName = registryNameFromSource(args.source, classified);
+    if (registryName) {
+      await installFromBahulamRegistry({ name: registryName, targetDir, cwd, args });
+      return;
+    }
+
     // Non-pi paths reuse the plugin-manage install machinery.
     let dest;
     if (classified.kind === 'git') {
@@ -194,8 +206,6 @@ export async function handleInstallCommand(argv, { cwd = process.cwd() } = {}) {
       dest = await installFromTarball({ url: classified.url, targetDir, force: args.force });
     } else if (classified.kind === 'local') {
       dest = await installFromLocal({ src: classified.path, targetDir, force: args.force });
-    } else if (classified.kind === 'name') {
-      throw new Error(`registry lookup for bare names is not yet wired into \`bahulam install\`. Provide a git URL, tarball URL, local path, or pi: source.`);
     } else {
       throw new Error(`could not resolve source: ${args.source}`);
     }
@@ -207,6 +217,118 @@ export async function handleInstallCommand(argv, { cwd = process.cwd() } = {}) {
   }
 }
 
+export function registryNameFromSource(source, classified = null) {
+  const raw = String(source || '').trim();
+  const prefix = 'bahulam:';
+  if (raw.toLowerCase().startsWith(prefix)) {
+    const name = raw.slice(prefix.length).trim();
+    if (!name) {
+      throw new Error(`bahulam registry source requires a plugin name, e.g. ${CYAN}bahulam:manim-studio${RESET}`);
+    }
+    return name;
+  }
+  if (classified?.kind === 'name') return classified.name;
+  return null;
+}
+
+async function installFromBahulamRegistry({ name, targetDir, cwd, args }) {
+  const entry = await resolveBahulamRegistryPlugin(name, { cwd });
+  const repository = entry.repository || entry.repo || entry.url;
+  if (!repository) {
+    throw new Error(`registry entry "${entry.name}" is missing a repository URL`);
+  }
+  const ref = args.ref || entry.ref || null;
+  const subdir = entry.subdir || entry.path || null;
+
+  process.stderr.write(
+    `${DIM}registry${RESET}  ${entry.name} → ${repository}` +
+    `${subdir ? `#${subdir}` : ''}${ref ? ` @ ${ref}` : ''}\n`,
+  );
+
+  const dest = await installFromGit({
+    url: repository,
+    targetDir,
+    name: entry.name,
+    ref,
+    subdir,
+    force: args.force,
+  });
+  await preflightAndReport({ dest, args, cwd });
+}
+
+export async function resolveBahulamRegistryPlugin(name, { cwd = process.cwd(), registry = null } = {}) {
+  const doc = registry || await loadBahulamPluginRegistry({ cwd });
+  const entries = Array.isArray(doc) ? doc : Array.isArray(doc?.plugins) ? doc.plugins : [];
+  if (!entries.length) {
+    throw new Error('Bahulam plugin registry did not contain any plugins');
+  }
+
+  const needle = normalizeRegistryName(name);
+  const entry = entries.find(item => {
+    const names = [
+      item?.name,
+      item?.slug,
+      item?.id,
+      ...(Array.isArray(item?.aliases) ? item.aliases : []),
+    ];
+    return names.some(candidate => normalizeRegistryName(candidate) === needle);
+  });
+
+  if (!entry) {
+    throw new Error(
+      `plugin not found in Bahulam registry: ${name}\n` +
+      `Available: ${entries.map(item => item.name).filter(Boolean).join(', ') || '(none)'}`,
+    );
+  }
+  return entry;
+}
+
+async function loadBahulamPluginRegistry({ cwd = process.cwd() } = {}) {
+  const explicit =
+    process.env.BAHULAM_PLUGIN_REGISTRY ||
+    process.env.BAHULAM_PLUGIN_REGISTRY_PATH ||
+    process.env.BAHULAM_PLUGIN_REGISTRY_URL;
+  if (explicit) return readRegistryLocation(explicit, cwd);
+
+  try {
+    return await readRegistryLocation(DEFAULT_BAHULAM_PLUGIN_REGISTRY_URL, cwd);
+  } catch (err) {
+    const localPath = findLocalRegistry(cwd);
+    if (localPath) return readRegistryJson(localPath);
+    throw new Error(`failed to load Bahulam plugin registry: ${err.message}`);
+  }
+}
+
+async function readRegistryLocation(location, cwd) {
+  if (/^https?:\/\//i.test(location)) {
+    const res = await fetch(location, { headers: { accept: 'application/json' } });
+    if (!res.ok) throw new Error(`${location} returned HTTP ${res.status}`);
+    return res.json();
+  }
+  const filePath = path.isAbsolute(location) ? location : path.resolve(cwd, location);
+  return readRegistryJson(filePath);
+}
+
+function readRegistryJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (err) {
+    throw new Error(`failed to read registry ${filePath}: ${err.message}`);
+  }
+}
+
+function findLocalRegistry(cwd) {
+  const candidates = [
+    path.resolve(cwd, '../awesome-bahulam-plugins/registry.json'),
+    path.resolve(cwd, 'awesome-bahulam-plugins/registry.json'),
+  ];
+  return candidates.find(candidate => fs.existsSync(candidate)) || null;
+}
+
+function normalizeRegistryName(name) {
+  return String(name || '').trim().replace(/^bahulam:/i, '').toLowerCase();
+}
+
 async function installPiWithScaffolding({ classified, targetDir, cwd, args }) {
   const { bahulamHome } = await import('../core/paths.mjs');
   const { discoverPiTools } = await import('../plugins/pi-compat/probe.mjs');
@@ -231,6 +353,12 @@ async function installPiWithScaffolding({ classified, targetDir, cwd, args }) {
   // Step 2: ensure the tools cache is present.
   const discovered = await discoverPiTools(piDir, { pluginName: classified.package_name });
 
+  // Step 2b: host check for required binaries. Install (unlike pull)
+  // implies "use this now", so a missing ffmpeg-class dep will fail at
+  // first tool call — better to fail loudly here. `--force` bypasses
+  // for offline provisioning / CI where deps land later.
+  await enforceHostRequirements({ piDir, packageName: classified.package_name, args });
+
   // Step 3: generate the pack directory (composes + state + agent + panel).
   process.stderr.write(`${DIM}scaffolding pack…${RESET}\n`);
   const { dest, slug, namespace, exposeTools, agentSlug } = scaffoldPiPack({
@@ -267,6 +395,28 @@ async function preflightAndReport({ dest, args, cwd, meta = null }) {
   // Do it in one command; the scaffolder path already has the pi ingredient.
   await resolveComposeDependencies(m, { targetDir: path.dirname(dest) });
 
+  // Host check for each composed pi ingredient (same policy as the
+  // scaffolder path). Blocks install if a required binary is missing.
+  const composes = m.spec?.composes || [];
+  if (composes.length && !meta) {
+    // meta present == scaffolder path already did this pre-scaffold
+    const { bahulamHome } = await import('../core/paths.mjs');
+    const piBaseDir = path.join(bahulamHome(), 'plugins-pi');
+    for (const compose of composes) {
+      if (!compose.package_name) continue;
+      const safeName = compose.package_name.replace(/[/@]/g, '_');
+      const piDir = path.join(piBaseDir, safeName);
+      if (!fs.existsSync(piDir)) continue;
+      try {
+        await enforceHostRequirements({ piDir, packageName: compose.package_name, args });
+      } catch (err) {
+        // Roll back the pack install — the composed dep won't work.
+        fs.rmSync(dest, { recursive: true, force: true });
+        throw err;
+      }
+    }
+  }
+
   if (args.json) {
     process.stdout.write(JSON.stringify({
       ok: true,
@@ -293,3 +443,62 @@ async function preflightAndReport({ dest, args, cwd, meta = null }) {
   }
   process.stderr.write(`\n  ${DIM}Open with:${RESET} ${CYAN}bahulam plugin ${m.metadata.name}${RESET}\n\n`);
 }
+
+/**
+ * Install-time host check: read the ingredient's requirements sidecar,
+ * verify each detected binary is on PATH. Throws with an actionable
+ * message (per-OS install hints) if anything required is missing.
+ * `--force` bypasses (for CI, offline provisioning, dev workflows where
+ * deps land later).
+ *
+ * Env vars / credentials are warn-only — many pi tools have optional
+ * features and blocking on a missing PEXELS_API_KEY when the user only
+ * wants media_probe is too aggressive.
+ */
+async function enforceHostRequirements({ piDir, packageName, args }) {
+  const { checkRequirementsAgainstHost, REQUIREMENTS_FILE, analyzeRequirements } =
+    await import('../plugins/pi-compat/requirements.mjs');
+
+  const sidecar = path.join(piDir, REQUIREMENTS_FILE);
+  let reqs = null;
+  if (fs.existsSync(sidecar)) {
+    try { reqs = JSON.parse(fs.readFileSync(sidecar, 'utf-8')); } catch { /* re-analyze */ }
+  }
+  if (!reqs) {
+    // Sidecar was missing (older ingredient install or analyzer crash) —
+    // synthesize on the fly so the check is never silently skipped.
+    let discoveredTools = null;
+    const toolsCache = path.join(piDir, '.bahulam-tools.json');
+    if (fs.existsSync(toolsCache)) {
+      try { discoveredTools = JSON.parse(fs.readFileSync(toolsCache, 'utf-8')); } catch { /* ignore */ }
+    }
+    reqs = analyzeRequirements(piDir, { discoveredTools });
+  }
+  if (!reqs?.system_binaries?.length) {
+    // Nothing to check.
+    return;
+  }
+
+  const host = checkRequirementsAgainstHost(reqs);
+  const missing = host.binaries.filter(b => !b.found);
+  if (missing.length === 0) return;
+
+  const platformKey = process.platform === 'darwin' ? 'darwin' : 'linux';
+  const lines = [];
+  lines.push(`${packageName} needs ${missing.length} system binar${missing.length === 1 ? 'y' : 'ies'} not found on your PATH:`);
+  for (const b of missing) {
+    const hint = b.install_hints?.[platformKey];
+    lines.push(`  · ${b.name}${hint ? ` — install: ${CYAN}${hint}${RESET}` : ''}`);
+  }
+  if (args.force) {
+    process.stderr.write(`${YELLOW}!${RESET} ${lines.join('\n')}\n`);
+    process.stderr.write(`${YELLOW}!${RESET} ${DIM}--force set — continuing anyway. Composed tools using these binaries will fail at first call.${RESET}\n`);
+    return;
+  }
+  const err = new Error(
+    `${lines.join('\n')}\n\n` +
+    `Install the missing binaries, then rerun. Or use ${CYAN}--force${RESET} to install without them (composed tools using these will fail at first call).\n` +
+    `Verify anytime with: ${CYAN}bahulam plugin doctor pi:${packageName}${RESET}`,
+  );
+  throw err;
+}

package/src/commands/plugin-manage.mjs

@@ -206,6 +206,7 @@ export async function installFromGit({ url, targetDir, name, ref, subdir, force
     await run('git', ['clone', '--depth', '1', ...(ref ? ['--branch', ref] : []), url, dest]);
   }
   writeStamp(dest, { origin: { kind: 'git', url, ref: ref || null, subdir: subdir || null } });
+  await installPackNpmDeps(dest, name);
   return dest;
 }
 
@@ -226,10 +227,53 @@ export async function installFromTarball({ url, targetDir, name, force }) {
   else await run('tar', ['-xzf', tmp, '-C', dest, '--strip-components=1']);
   fs.unlinkSync(tmp);
   writeStamp(dest, { origin: { kind: 'tarball', url } });
+  await installPackNpmDeps(dest, guessed);
   return dest;
 }
 
-export async function installFromPi({ packageName, versionRange, force }) {
+// Materialize a hand-authored pack's node_modules/ after clone/copy/extract.
+// Shared by installFromGit / installFromTarball / installFromLocal so a pack
+// with `package.json::dependencies` doesn't need `cd ~/.bahulam/plugins/x && npm install`.
+async function installPackNpmDeps(packDir, displayName = null) {
+  const pkgPath = path.join(packDir, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const { installPackageDependencies } = await import('../plugins/npm-install.mjs');
+    await installPackageDependencies({
+      dir: packDir,
+      packageName: displayName || path.basename(packDir),
+      kind: 'pack',
+      forceScripts: false,  // hand-authored packs default to --ignore-scripts
+    });
+  }
+  // Requirements preflight for the pack itself. Walks the pack's own
+  // source (tools/*.mjs etc.) to surface system binaries the pack shells
+  // out to and env vars it reads. Same analyzer that pi ingredients use.
+  await surfacePackRequirements(packDir, displayName);
+}
+
+async function surfacePackRequirements(packDir, displayName = null) {
+  try {
+    const { analyzeRequirements, formatRequirementsReport } =
+      await import('../plugins/pi-compat/requirements.mjs');
+    const reqs = analyzeRequirements(packDir);
+    if (!reqs || (!reqs.system_binaries.length && !reqs.env_vars.length && !reqs.readme_sections.length && !reqs.skills_available.length)) {
+      return; // Nothing worth telling the user about.
+    }
+    const lines = formatRequirementsReport(reqs, { verbose: false });
+    for (const l of lines) {
+      const icon = l.level === 'warn' ? `${YELLOW}!${RESET}` : l.level === 'ok' ? `${GREEN}✓${RESET}` : `${DIM}·${RESET}`;
+      process.stderr.write(`  ${icon} ${l.text}\n`);
+    }
+    if (reqs.system_binaries?.length) {
+      const name = displayName || path.basename(packDir);
+      process.stderr.write(`  ${DIM}run${RESET}  ${CYAN}bahulam plugin doctor ${name}${RESET} ${DIM}to check your environment${RESET}\n`);
+    }
+  } catch (err) {
+    if (process.env.DEBUG) process.stderr.write(`  ${DIM}requirements analyzer skipped: ${err.message}${RESET}\n`);
+  }
+}
+
+export async function installFromPi({ packageName, versionRange, force, forceScripts = false }) {
   // Pi packages live in ~/.bahulam/plugins-pi/ (or $BAHULAM_HOME/plugins-pi/)
   // so `bahulam plugin list` doesn't confuse them with our own packs. The
   // tool executor reads from the same canonical path via bahulamHome().
@@ -255,31 +299,17 @@ export async function installFromPi({ packageName, versionRange, force }) {
     if (!tarballs.length) throw new Error(`npm pack produced no tarball for ${spec}`);
     await run('tar', ['-xzf', path.join(tmp, tarballs[0]), '-C', dest, '--strip-components=1']);
 
-    // Pi packages typically declare their runtime deps under
-    // `peerDependencies` (assuming pi will provide them). We're the host
-    // now, so materialize those. Two steps because npm arborist crashes
-    // when peerDependencies use `*` versions during install:
-    //   1. Rewrite package.json to move peers into dependencies (resolved
-    //      version), and drop the peers block so the resolver stops
-    //      reconciling.
-    //   2. `npm install` — the dependencies section is normal for npm.
-    const pkgPath = path.join(dest, 'package.json');
-    let pkgJson = {};
-    try { pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')); } catch { /* ignore */ }
-    const merged = { ...(pkgJson.dependencies || {}) };
-    for (const [name, range] of Object.entries(pkgJson.peerDependencies || {})) {
-      if (!merged[name]) merged[name] = range === '*' ? 'latest' : range;
-    }
-    if (Object.keys(merged).length) {
-      const rewritten = { ...pkgJson, dependencies: merged };
-      delete rewritten.peerDependencies;
-      fs.writeFileSync(pkgPath, JSON.stringify(rewritten, null, 2));
-      process.stderr.write(`  ${DIM}installing ${Object.keys(merged).length} pi runtime deps…${RESET}\n`);
-      await run('npm', ['install', '--no-audit', '--no-fund', '--legacy-peer-deps', '--silent'], {
-        cwd: dest,
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-    }
+    // Materialize node_modules for the ingredient. Handles pi's peer-dep
+    // quirk and gates postinstall scripts on the verified-package list
+    // (§13.6.1c of PRD-102) so unreviewed pi packages can't run arbitrary
+    // code at pull time.
+    const { installPackageDependencies } = await import('../plugins/npm-install.mjs');
+    await installPackageDependencies({
+      dir: dest,
+      packageName,
+      kind: 'pi',
+      forceScripts,
+    });
 
     // Read the resolved version so the stamp captures what we actually got.
     let resolvedVersion = null;
@@ -303,15 +333,36 @@ export async function installFromPi({ packageName, versionRange, force }) {
     // `cat` and lets executor invocations skip the first-run probe cost.
     // Best-effort: failure here is non-fatal (returns tools:[] until next
     // invocation retries) so a broken extension can still be diagnosed.
+    let discoveredShape = null;
     try {
       const { discoverPiTools } = await import('../plugins/pi-compat/probe.mjs');
-      const shape = await discoverPiTools(dest, { pluginName: packageName, force: true });
-      process.stderr.write(`  ${DIM}discovered${RESET}  ${(shape.tools || []).length} tool(s), ${(shape.commands || []).length} command(s)\n`);
+      discoveredShape = await discoverPiTools(dest, { pluginName: packageName, force: true });
+      process.stderr.write(`  ${DIM}discovered${RESET}  ${(discoveredShape.tools || []).length} tool(s), ${(discoveredShape.commands || []).length} command(s)\n`);
     } catch (probeErr) {
       process.stderr.write(`  ${YELLOW}!${RESET} Tool discovery failed: ${probeErr.message}\n`);
       process.stderr.write(`  ${DIM}The package installed but no tools were probed. Re-probe with:${RESET}\n`);
       process.stderr.write(`  ${DIM}  node -e "import('${path.resolve('src/plugins/pi-compat/probe.mjs')}').then(m => m.discoverPiTools('${dest}', { pluginName: '${packageName}', force: true }))"${RESET}\n`);
     }
+
+    // Requirements preflight (§13.6.1i). Never blocks — this is a heads-up
+    // before the user commits to composing the ingredient. Findings land
+    // in <dest>/.bahulam-requirements.json for the scaffolder + doctor.
+    try {
+      const { analyzeRequirements, formatRequirementsReport } = await import('../plugins/pi-compat/requirements.mjs');
+      const reqs = analyzeRequirements(dest, { discoveredTools: discoveredShape });
+      const lines = formatRequirementsReport(reqs, { verbose: false });
+      for (const l of lines) {
+        const icon = l.level === 'warn' ? `${YELLOW}!${RESET}` : l.level === 'ok' ? `${GREEN}✓${RESET}` : `${DIM}·${RESET}`;
+        process.stderr.write(`  ${icon} ${l.text}\n`);
+      }
+      const missingBin = (reqs.system_binaries || []).length;
+      if (missingBin > 0) {
+        process.stderr.write(`  ${DIM}run${RESET}  ${CYAN}bahulam plugin doctor ${packageName}${RESET} ${DIM}to check your environment${RESET}\n`);
+      }
+    } catch (reqErr) {
+      // Non-fatal — analyzer is a nice-to-have.
+      if (process.env.DEBUG) process.stderr.write(`  ${DIM}requirements analyzer skipped: ${reqErr.message}${RESET}\n`);
+    }
   } catch (err) {
     rmrf(dest);
     throw new Error(`pi install failed for ${spec}: ${err.message}`);
@@ -330,8 +381,11 @@ export async function installFromLocal({ src, targetDir, force }) {
     rmrf(dest);
   }
   fs.mkdirSync(targetDir, { recursive: true });
-  fs.cpSync(src, dest, { recursive: true });
+  // Copy the pack but skip node_modules — we'll materialize fresh below
+  // (source's node_modules can be stale, platform-specific, or bloat).
+  fs.cpSync(src, dest, { recursive: true, filter: (s) => path.basename(s) !== 'node_modules' });
   writeStamp(dest, { origin: { kind: 'local', path: src } });
+  await installPackNpmDeps(dest, name);
   return dest;
 }
 
@@ -621,6 +675,137 @@ async function cmdValidate(args, cwd) {
   if (!result.ok) process.exit(1);
 }
 
+// ── doctor ─────────────────────────────────────────────────────────
+//
+// Check that an installed pack's composed ingredients (pi:) have their
+// required system binaries and env vars present on the host. Exits non-
+// zero on missing required items (script-friendly for CI setup checks).
+
+async function cmdDoctor(args, cwd) {
+  const target = args.pluginName;
+  const { bahulamHome } = await import('../core/paths.mjs');
+  const { analyzeRequirements, formatRequirementsReport, checkRequirementsAgainstHost, REQUIREMENTS_FILE } =
+    await import('../plugins/pi-compat/requirements.mjs');
+  const piBaseDir = path.join(bahulamHome(), 'plugins-pi');
+
+  // Which ingredient dirs to check?
+  //   - `bahulam plugin doctor <pack-slug>` → all pi: composes referenced by that pack
+  //   - `bahulam plugin doctor pi:<name>` → that specific pi ingredient
+  //   - `bahulam plugin doctor` (no arg) → every pi ingredient installed
+  let ingredientDirs = [];
+  if (!target) {
+    if (fs.existsSync(piBaseDir)) {
+      for (const entry of fs.readdirSync(piBaseDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && !entry.name.startsWith('.')) {
+          ingredientDirs.push({ label: entry.name, dir: path.join(piBaseDir, entry.name) });
+        }
+      }
+    }
+  } else if (target.startsWith('pi:')) {
+    const packageName = target.slice(3);
+    const safe = packageName.replace(/[/@]/g, '_');
+    const dir = path.join(piBaseDir, safe);
+    if (!fs.existsSync(dir)) throw new Error(`pi ingredient not installed: ${packageName}`);
+    ingredientDirs.push({ label: packageName, dir });
+  } else {
+    const found = findByName(target, cwd);
+    if (!found) throw new Error(`plugin not found: ${target}`);
+    const scan = readManifest(found.directory);
+    const composes = scan?.manifest?.spec?.composes || [];
+    for (const c of composes) {
+      if (!c.package_name) continue;
+      const safe = c.package_name.replace(/[/@]/g, '_');
+      const dir = path.join(piBaseDir, safe);
+      if (!fs.existsSync(dir)) {
+        process.stderr.write(`  ${YELLOW}!${RESET} pi ingredient ${c.package_name} referenced by ${found.name} but not installed\n`);
+        continue;
+      }
+      ingredientDirs.push({ label: `${found.name} ← pi:${c.package_name}`, dir });
+    }
+    // Also check the pack's OWN source — hand-authored packs may shell
+    // out to system binaries (manim, docker, ffmpeg) or read env vars
+    // regardless of whether they compose any pi ingredients.
+    ingredientDirs.push({ label: found.name, dir: found.directory, isPack: true });
+  }
+
+  const report = [];
+  let missingRequired = 0;
+
+  for (const { label, dir } of ingredientDirs) {
+    // Load or (re)compute the requirements sidecar.
+    let reqs = null;
+    const sidecar = path.join(dir, REQUIREMENTS_FILE);
+    if (fs.existsSync(sidecar)) {
+      try { reqs = JSON.parse(fs.readFileSync(sidecar, 'utf-8')); } catch { /* re-analyze */ }
+    }
+    if (!reqs) {
+      try {
+        let tools = null;
+        const toolsPath = path.join(dir, '.bahulam-tools.json');
+        if (fs.existsSync(toolsPath)) tools = JSON.parse(fs.readFileSync(toolsPath, 'utf-8'));
+        reqs = analyzeRequirements(dir, { discoveredTools: tools });
+      } catch (err) {
+        report.push({ label, dir, error: err.message });
+        continue;
+      }
+    }
+    const host = checkRequirementsAgainstHost(reqs);
+    const missing = host.binaries.filter(b => !b.found).length;
+    missingRequired += missing;
+    report.push({ label, dir, reqs, host, missing });
+  }
+
+  if (args.json) {
+    process.stdout.write(JSON.stringify({
+      ok: missingRequired === 0,
+      missing_binaries: missingRequired,
+      checked: report,
+    }, null, 2) + '\n');
+    if (missingRequired > 0) process.exit(1);
+    return;
+  }
+
+  if (report.length === 0) {
+    process.stderr.write(`${DIM}No pi ingredients found to check.${RESET}\n`);
+    return;
+  }
+
+  for (const r of report) {
+    process.stderr.write(`\n${BOLD}${CYAN}${r.label}${RESET}  ${DIM}${r.dir}${RESET}\n`);
+    if (r.error) { process.stderr.write(`  ${RED}✗${RESET} ${r.error}\n`); continue; }
+    const lines = formatRequirementsReport(r.reqs, { verbose: false });
+    for (const l of lines) {
+      const icon = l.level === 'warn' ? `${YELLOW}!${RESET}` : l.level === 'ok' ? `${GREEN}✓${RESET}` : `${DIM}·${RESET}`;
+      process.stderr.write(`  ${icon} ${l.text}\n`);
+    }
+    if (r.host.binaries.length) {
+      process.stderr.write(`  ${DIM}binaries:${RESET}\n`);
+      for (const b of r.host.binaries) {
+        if (b.found) {
+          process.stderr.write(`    ${GREEN}✓${RESET} ${b.name}${b.version ? `  ${DIM}${b.version}${RESET}` : ''}${b.path ? `  ${DIM}${b.path}${RESET}` : ''}\n`);
+        } else {
+          const hint = b.install_hints?.[process.platform === 'darwin' ? 'darwin' : 'linux'];
+          process.stderr.write(`    ${RED}✗${RESET} ${b.name}${hint ? `  ${DIM}install:${RESET} ${CYAN}${hint}${RESET}` : ''}\n`);
+        }
+      }
+    }
+    if (r.host.env_vars.length) {
+      process.stderr.write(`  ${DIM}env vars:${RESET}\n`);
+      for (const v of r.host.env_vars) {
+        const status = v.set ? `${GREEN}✓${RESET}` : (v.credential ? `${RED}✗${RESET}` : `${YELLOW}⚠${RESET}`);
+        process.stderr.write(`    ${status} ${v.name}${v.credential ? ` ${DIM}(credential)${RESET}` : ''}\n`);
+      }
+    }
+  }
+  process.stderr.write('\n');
+  if (missingRequired > 0) {
+    process.stderr.write(`${RED}✗${RESET} ${missingRequired} required binar${missingRequired === 1 ? 'y' : 'ies'} missing.\n\n`);
+    process.exit(1);
+  } else {
+    process.stderr.write(`${GREEN}✓${RESET} all detected requirements satisfied.\n\n`);
+  }
+}
+
 export async function handlePluginManagementCommand(args, { cwd = process.cwd(), throwOnError = false } = {}) {
   try {
     switch (args.action) {
@@ -630,6 +815,7 @@ export async function handlePluginManagementCommand(args, { cwd = process.cwd(),
       case 'enable': toggle(args, cwd, true); return;
       case 'disable': toggle(args, cwd, false); return;
       case 'info': cmdInfo(args, cwd); return;
+      case 'doctor': await cmdDoctor(args, cwd); return;
       case 'update': case 'upgrade': await cmdUpdate(args, cwd); return;
       default: throw new Error(`unknown plugin action: ${args.action}`);
     }

package/src/config/model-catalog-default.json

@@ -33,9 +33,6 @@
     {"value": "qwen/qwq-32b", "label": "QwQ 32B", "provider": "qwen", "inputCost": 0.2, "outputCost": 0.2, "context": 131072, "maxOutput": 32768, "supportsTools": true, "supportsReasoning": true, "harnessValidated": false},
     {"value": "minimax/minimax-m3", "label": "MiniMax M3", "provider": "minimax", "inputCost": 0.5, "outputCost": 2.0, "context": 1048576, "maxOutput": 512000, "supportsTools": true, "supportsReasoning": false, "harnessValidated": true, "platformAccessTier": ["pro", "tier_49", "tier_99"]},
     {"value": "minimax/minimax-m2.1", "label": "MiniMax M2.1", "provider": "minimax", "inputCost": 0.3, "outputCost": 1.1, "context": 204800, "maxOutput": 131072, "supportsTools": true, "supportsReasoning": false, "harnessValidated": true, "platformAccessTier": ["pro", "tier_49", "tier_99"]},
-    {"value": "xiaomi/mimo-v2.5-pro", "label": "MiMo V2.5 Pro", "provider": "xiaomi", "inputCost": 0.5, "outputCost": 2.0, "context": 1050000, "maxOutput": 131072, "supportsTools": true, "supportsReasoning": false, "harnessValidated": true, "platformAccessTier": ["pro", "tier_49", "tier_99"]},
-    {"value": "xiaomi/mimo-v2.5", "label": "MiMo V2.5", "provider": "xiaomi", "inputCost": 0.3, "outputCost": 1.0, "context": 1050000, "maxOutput": 131072, "supportsTools": true, "supportsReasoning": false, "harnessValidated": true, "cacheProfile": "{\"type\": \"prefix_hash\", \"provider_hint\": \"Xiaomi\"}", "platformAccessTier": ["pro", "tier_49", "tier_99"]},
-    {"value": "xiaomi/mimo-v2-flash", "label": "MiMo V2 Flash", "provider": "xiaomi", "inputCost": 0.1, "outputCost": 0.3, "context": 131072, "maxOutput": 16384, "supportsTools": true, "supportsReasoning": false, "harnessValidated": false},
     {"value": "moonshotai/kimi-k2.5", "label": "Kimi K2.5", "provider": "kimi", "inputCost": 0.44, "outputCost": 2.0, "context": 262144, "maxOutput": 262144, "supportsTools": true, "supportsReasoning": false, "harnessValidated": true, "platformAccessTier": ["pro", "tier_49", "tier_99"]},
     {"value": "moonshotai/kimi-k2", "label": "Kimi K2", "provider": "kimi", "inputCost": 0.44, "outputCost": 2.0, "context": 131072, "maxOutput": 100352, "supportsTools": true, "supportsReasoning": false, "harnessValidated": false},
     {"value": "moonshotai/kimi-k2-instruct", "label": "Kimi K2 Instruct", "provider": "kimi", "inputCost": 0.44, "outputCost": 2.0, "context": 131072, "maxOutput": 65536, "supportsTools": true, "supportsReasoning": false, "harnessValidated": false},
@@ -60,7 +57,6 @@
     {"value": "stealth/ox-alpha", "label": "Stealth OX Alpha", "provider": "stealth", "inputCost": 0.3, "outputCost": 1.0, "context": 1048576, "maxOutput": 131072, "supportsTools": true, "supportsReasoning": false, "harnessValidated": true, "cacheProfile": "{\"type\": \"prefix_hash\", \"provider_hint\": \"Stealth\"}", "platformAccessTier": ["pro", "tier_49", "tier_99"]},
     {"value": "upstage/solar-pro4", "label": "Solar Pro 4", "provider": "upstage", "inputCost": 0.3, "outputCost": 1.0, "context": 524288, "maxOutput": 131072, "supportsTools": true, "supportsReasoning": false, "harnessValidated": false, "cacheProfile": "{\"type\": \"prefix_hash\", \"provider_hint\": \"Upstage\"}", "platformAccessTier": ["pro", "tier_49", "tier_99"]},
     {"value": "qwen/qwen3-coder:free", "label": "Qwen3 Coder (Free)", "provider": "qwen", "inputCost": 0, "outputCost": 0, "context": 131072, "maxOutput": 65536, "supportsTools": true, "supportsReasoning": false, "harnessValidated": false},
-    {"value": "xiaomi/mimo-v2-flash:free", "label": "MiMo V2 Flash (Free)", "provider": "xiaomi", "inputCost": 0, "outputCost": 0, "context": 131072, "maxOutput": 16384, "supportsTools": true, "supportsReasoning": false, "harnessValidated": false},
     {"value": "meta-llama/llama-3.3-70b-instruct:free", "label": "Llama 3.3 70B (Free)", "provider": "meta", "inputCost": 0, "outputCost": 0, "context": 131072, "maxOutput": 8192, "supportsTools": true, "supportsReasoning": false, "harnessValidated": false},
     {"value": "qwen/qwen3-8b:free", "label": "Qwen3 8B (Free)", "provider": "qwen", "inputCost": 0, "outputCost": 0, "context": 131072, "maxOutput": 8192, "supportsTools": true, "supportsReasoning": false, "harnessValidated": false},
     {"value": "nvidia/nemotron-3-ultra-550b-a55b:free", "label": "Nemotron 3 Ultra 550B (Free)", "provider": "nvidia", "inputCost": 0, "outputCost": 0, "context": 1000000, "maxOutput": 65536, "supportsTools": true, "supportsReasoning": false, "harnessValidated": true, "cacheProfile": "{\"type\": \"prefix_hash\", \"provider_hint\": \"NVIDIA\"}", "platformAccessTier": ["pro", "tier_49", "tier_99"]},

package/src/core/resume-mode.mjs

@@ -30,7 +30,6 @@ const MODEL_CONTEXT_WINDOWS = {
   'openai/gpt-5':                       400000,
   'openai/gpt-5-mini':                  400000,
   'google/gemini-2.5-pro':              1000000,
-  'xiaomi/mimo-v2.5':                   128000,
 };
 const DEFAULT_CONTEXT_WINDOW = 128000;
 

package/src/core/stream-client.mjs

@@ -171,6 +171,7 @@ export class BahulamStreamClient {
         this._pauseWaiters = new Set();
         this._abort = null;
         this._toolAbort = null;
+        this._sawComplete = false;
 
         // Transport mode:
         //   'remote' → cloud backend runs the agent loop server-side.
@@ -352,6 +353,7 @@ export class BahulamStreamClient {
         this._cancelled = false;
         this.currentTaskId = null;
         this._firstEventTimedOut = false;
+        this._sawComplete = false;
 
         // Bundled mode: spawn the local Python runtime on first turn.
         // After this, this.baseUrl points at http://127.0.0.1:<random-port>
@@ -500,6 +502,21 @@ export class BahulamStreamClient {
             if (this._cancelled) {
                 return;
             }
+            if (this._sawComplete) {
+                telemetry.track('stream.post_complete_error_ignored', {
+                    task_id: this.currentTaskId || null,
+                    last_event_id: this.lastEventId || null,
+                    message: err?.message || 'stream closed after complete',
+                    error_code: err?.cause?.code || err?.code || '',
+                });
+                transportDebug('execute.post_complete_error_ignored', {
+                    task_id: this.currentTaskId || null,
+                    last_event_id: this.lastEventId || null,
+                    error: err?.message || 'stream closed after complete',
+                    code: err?.cause?.code || err?.code || '',
+                });
+                return;
+            }
             if (this._firstEventTimedOut) {
                 yield {
                     type: EVENT_TYPES.ERROR,
@@ -579,6 +596,7 @@ export class BahulamStreamClient {
         }
 
         if (event === EVENT_TYPES.COMPLETE) {
+            this._sawComplete = true;
             this._persistMemoryFactsFromComplete(data);
         }