@bahulam/code 0.1.13 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bahulam/code",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "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

@@ -231,6 +231,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 +273,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 +321,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);
         }
 

package/src/daemon/session-core.mjs

@@ -99,10 +99,13 @@ export const DAEMON_OWNED_FIELDS = Object.freeze([
  *   • It's input state tied to a keyboard (`inputHistory`).
  *   • It's a rendering flag whose value depends on the current visible
  *     transcript, not the session's actual state (`inSubAgent`).
+ *   • It's an active renderer collection that does not JSON round-trip
+ *     safely (`activeSubAgentRuns` is a Map).
  */
 export const CLIENT_OWNED_SESSION_FIELDS = Object.freeze([
   'inputHistory',
   'inSubAgent',
+  'activeSubAgentRuns',
   'creditsLowWarned',
   'msgsLowWarned',
   '_lastEmittedThinking',

package/src/local-service/agent-relay.mjs

@@ -748,6 +748,8 @@ export class LocalAgentRelay {
       lines.push(
         'Use analyze_image(path=..., question=...) for images.',
         'Use read_table(path=...) for CSV/TSV/Excel-style tables.',
+        'Use browser/web inspection tools for HTML and browser-rendered web assets when available.',
+        'For video and audio, inspect file metadata and ask for a transcript or frame extraction when content analysis is needed.',
         'Use read_attachment(path=...) for text, PDFs, Markdown, JSON/YAML, and Jupyter notebooks.',
         'For unsupported binary files, inspect metadata or ask before attempting lossy conversion.',
       );
@@ -902,7 +904,10 @@ function attachmentToolHint(file) {
   const ext = String(file?.path || file?.name || '').split('.').pop().toLowerCase();
   if (kind === 'image' || mime.startsWith('image/')) return 'analyze_image';
   if (kind === 'spreadsheet' || kind === 'table' || ['csv', 'tsv', 'xlsx', 'xls', 'ods'].includes(ext)) return 'read_table';
-  if (['pdf', 'markdown', 'text', 'code', 'config', 'notebook'].includes(kind) || ['txt', 'md', 'mdx', 'pdf', 'json', 'yaml', 'yml', 'toml', 'html', 'xml', 'ipynb', 'log', 'rst', 'sql', 'sh'].includes(ext)) return 'read_attachment';
+  if (kind === 'web' || ['html', 'htm'].includes(ext)) return 'web_preview';
+  if (kind === 'video' || mime.startsWith('video/')) return 'media_metadata';
+  if (kind === 'audio' || mime.startsWith('audio/')) return 'media_metadata';
+  if (['pdf', 'markdown', 'text', 'code', 'config', 'notebook'].includes(kind) || ['txt', 'md', 'mdx', 'pdf', 'json', 'yaml', 'yml', 'toml', 'xml', 'ipynb', 'log', 'rst', 'sql', 'sh'].includes(ext)) return 'read_attachment';
   return '';
 }