@polderlabs/bizar 10.20.0 → 10.20.1

package/cli/commands/models.mjs

@@ -1473,6 +1473,168 @@ async function pickModelsInteractive({ ordered, candidates, selected, lastOrder,
   }
 }
 
+// ── 10.19.9 Phase 3: post-confirm status screen ──────────────────────────────
+//
+// After the operator confirms a picker selection, `bizar models` prints a
+// status screen showing one row per picked ID with a ✔ / ✖ / ⤳ icon. The
+// shape mirrors `cli/doctor.mjs#runDoctor` (per-row ✔ / ✖ pattern) so
+// operators see a familiar surface. The renderer is CLI-only — the
+// SessionStart hook has no TTY and no outbound HTTP and must NOT import
+// these helpers.
+
+const STATUS_ICON = Object.freeze({
+  fresh: '✔',       // ✔
+  refreshed: '✔',   // ✔
+  unavailable: '✖', // ✖
+  preexisting: '⤳', // ⤳
+});
+
+/**
+ * Classify one picked id into the four status states the renderer can
+ * print. Pure: no I/O, no side effects.
+ *
+ *   'preexisting'  — the operator-confirmed pick already lived in
+ *                    userSelected.models BEFORE this run. Wins over every
+ *                    other branch (the operator explicitly re-selected
+ *                    a known-good pick).
+ *   'unavailable'  — the post-confirm Models.dev enrichment returned
+ *                    profile === null AND no _gateway.name fallback was
+ *                    available. Surface as ✖.
+ *   'refreshed'    — profile exists with metadata.source === 'gateway-
+ *                    fallback' (Phase 1 contract). Models.dev missed but
+ *                    the gateway's name field rescued the row. Surface
+ *                    as ✔ (refreshed).
+ *   'fresh'        — profile exists with metadata.source === 'models.dev'
+ *                    (the Phase 2 enrichment succeeded). Surface as ✔.
+ *
+ * @param {string} id            the picked id (e.g. 'anthropic/claude-3-5-sonnet')
+ * @param {object|null} profile  the Phase 2 enrichment result for that id
+ *                               (null when both Models.dev AND _gateway.name missed)
+ * @param {Set<string>} [preExisting]  snapshot of userSelected.models BEFORE applyModels
+ *                                      overwrote the block; undefined is treated as empty
+ * @returns {'fresh'|'refreshed'|'unavailable'|'preexisting'}
+ */
+export function classifyPickStatus(id, profile, preExisting) {
+  if (preExisting instanceof Set && preExisting.has(id)) return 'preexisting';
+  if (!profile) return 'unavailable';
+  if (profile.metadata && profile.metadata.source === 'gateway-fallback') return 'refreshed';
+  return 'fresh';
+}
+
+/**
+ * Resolve the profile object from the heterogeneous shapes Phase 2 hands
+ * us: a `Map<string, object|null>` when called from `run()`, a plain
+ * object when called from a fixture, or `undefined` for "the enrichment
+ * step never ran for this id".
+ */
+function resolveProfile(profiles, id) {
+  if (!profiles) return null;
+  if (profiles instanceof Map) {
+    return profiles.has(id) ? profiles.get(id) : null;
+  }
+  if (typeof profiles === 'object') {
+    return Object.prototype.hasOwnProperty.call(profiles, id) ? profiles[id] : null;
+  }
+  return null;
+}
+
+function formatStatusRow({ id, profile, status }) {
+  const icon = STATUS_ICON[status];
+  if (status === 'preexisting') {
+    return chalk.dim(`  ${icon} ${id}  (already in userSelected)`);
+  }
+  if (status === 'unavailable') {
+    // Profile is null AND no _gateway.name fallback. The renderer never
+    // reaches this branch when Phase 2's _gateway.name plumbing survived.
+    return chalk.red(`  ${icon} ${id}  (metadata unavailable)`);
+  }
+  // 'fresh' or 'refreshed' — both render as ✔ with the model name.
+  // For 'refreshed' the only label available is the Phase 1 _gateway.name;
+  // for 'fresh' we prefer Models.dev's name and fall back to _gateway.name.
+  const label = (profile && profile.name)
+    || (profile && profile._gateway && profile._gateway.name)
+    || id;
+  return chalk.green(`  ${icon} ${id}  (${label})`);
+}
+
+/**
+ * Render the post-confirm status screen for one picker run.
+ *
+ * CLI-only surface — do NOT import from the SessionStart hook (no TTY,
+ * no outbound HTTP). The helper writes to `out` based on `isTTY`:
+ *   - isTTY=true  → one `  <icon> <id>  (<label>)` line per picked id
+ *                   plus a footer `N passed, M failed, K skipped`.
+ *   - isTTY=false → one collapsed line `  v N passed, M failed, K skipped`
+ *                   appended to the existing "Saved" block (so piped
+ *                   callers see one summary line, not a flood of rows).
+ *
+ * Always returns `{ perPick, totals, exitCode }` so `--json` callers can
+ * embed the data in the JSON envelope without re-implementing the
+ * classification:
+ *   - status.perPick = [{ id, status, hasProfile }]
+ *   - status.totals  = { passed, failed, skipped }
+ *   - exitCode       = 0 when at least one ✔; 2 when EVERY row is ✖;
+ *                      0 otherwise (mixed picks, or every pick ⤳).
+ *
+ * The caller decides whether to call `process.exit(exitCode)`; the
+ * renderer never exits on its own.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.picked            ids the operator confirmed
+ * @param {Map<string, object|null>|object} [opts.profiles]  Phase 2 enrichment map
+ * @param {Set<string>} [opts.preExisting]  userSelected.models snapshot BEFORE applyModels
+ * @param {object} [opts.fetchSummary]      unused today; reserved for Phase 4 disable surfacing
+ * @param {NodeJS.WritableStream} [opts.out] defaults to process.stdout (test fixtures inject a stub)
+ * @param {boolean} [opts.isTTY=true]       when false, print the single-line collapse
+ * @returns {{ perPick: Array<{id:string, status:string, hasProfile:boolean}>, totals: {passed:number, failed:number, skipped:number}, exitCode: 0|2 }}
+ */
+export function renderPickStatusScreen({
+  picked = [],
+  profiles,
+  preExisting,
+  fetchSummary = null,
+  out = process.stdout,
+  isTTY = true,
+} = {}) {
+  const perPick = [];
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const id of picked) {
+    const profile = resolveProfile(profiles, id);
+    const status = classifyPickStatus(id, profile, preExisting);
+    const hasProfile = !!profile;
+    perPick.push({ id, status, hasProfile });
+    if (status === 'preexisting') skipped += 1;
+    else if (status === 'unavailable') failed += 1;
+    else passed += 1;
+  }
+  const totals = { passed, failed, skipped };
+
+  if (isTTY) {
+    for (const entry of perPick) {
+      const profile = resolveProfile(profiles, entry.id);
+      out.write(formatStatusRow({ id: entry.id, profile, status: entry.status }) + '\n');
+    }
+    const summary = chalk.dim(`  ${passed} passed, ${failed} failed, ${skipped} skipped`);
+    out.write(summary + '\n');
+  } else {
+    const summary = chalk.dim(`  v ${passed} passed, ${failed} failed, ${skipped} skipped`);
+    out.write(summary + '\n');
+  }
+
+  // Exit-code contract: 0 when at least one ✔; 2 only when EVERY row is ✖.
+  // Mixed picks and all-⤳ picks both exit 0 (the operator got a usable
+  // confirmation, even if some picks couldn't be enriched).
+  const exitCode = (passed > 0)
+    ? 0
+    : (failed === picked.length && picked.length > 0)
+      ? 2
+      : 0;
+
+  return { perPick, totals, exitCode };
+}
+
 /**
  * Build a small async iterator over `stdin` lines.
  * Returns null from `next()` when the stream ends.
@@ -1582,6 +1744,24 @@ function showHelp() {
   userSelected. If userSelected is empty, every dispatch inherits the
   active session model.
 
+  Post-confirm status screen (interactive only): after the picker saves a
+  selection, every confirmed id is reported on its own row with one of:
+
+    ✔   Models.dev profile retrieved (or carried over via the gateway
+        _gateway.name fallback). The label shows the profile name.
+    ✖   Models.dev miss AND no _gateway.name fallback. The row prints
+        \`(metadata unavailable)\`.
+    ⤳   Id was already in userSelected.models before this run
+        (re-confirmed pick). Label: \`(already in userSelected)\`.
+
+  The screen ends with a footer \`N passed, M failed, K skipped\`. In a
+  TTY the screen is multi-row; in a pipe it collapses to one summary
+  line appended to the existing \"Saved N model(s)\" block. \`--json\`
+  carries the equivalent data in \`status.perPick\` (one entry per
+  picked id) and \`status.totals\` ({passed, failed, skipped}). Exit
+  code is 0 when at least one ✔ was reported, 2 when every row is ✖;
+  mixed ✔+✖ still exits 0.
+
   Endpoint resolution order: $BIZAR_MODEL_ROUTER_URL / $ANTHROPIC_BASE_URL
     -> ~/.claude/settings.json#env.BIZAR_MODEL_ROUTER_URL
     -> model-router.json#endpoint
@@ -1841,6 +2021,12 @@ export async function run(name, args, isHelpRequest, deps = {}) {
 
   const router = loadRouter(routerPath);
   const { models: current } = currentSelection(router);
+  // 10.19.9 Phase 3: capture a snapshot of userSelected.models BEFORE
+  // applyModels overwrites the block, so the post-confirm status screen
+  // can classify re-confirmed picks as `preexisting` (⤳) instead of
+  // `fresh` (✔). `current` is read once and shared with pickModelsFn;
+  // we wrap it in a Set so classifyPickStatus can use `.has(id)`.
+  const preExisting = new Set(current);
   const picked = await pickModelsFn({ candidates, current });
 
   // Phase 2 (10.19.8): the Models.dev catalog fetch moves HERE — only
@@ -1907,6 +2093,18 @@ export async function run(name, args, isHelpRequest, deps = {}) {
     // Phase 2 the array equals the picks list (no filtering); Phase 4
     // will filter to only the IDs that actually received a profile.
     const enriched = picked.slice();
+    // 10.19.9 Phase 3: --json gains `status.perPick` + `status.totals`.
+    // The renderer writes nothing to stdout in --json mode (out is a
+    // no-op writable; isTTY=false keeps the single-line collapse from
+    // leaking into the JSON stream). The JSON envelope carries the
+    // equivalent data shape.
+    const statusResult = renderPickStatusScreen({
+      picked,
+      profiles: profilesMap,
+      preExisting,
+      out: { write: () => true },
+      isTTY: false,
+    });
     process.stdout.write(JSON.stringify({
       applied: block,
       endpoint,
@@ -1916,7 +2114,9 @@ export async function run(name, args, isHelpRequest, deps = {}) {
       modelsDev: modelsDevStatus,
       sync,
       picker,
+      status: { perPick: statusResult.perPick, totals: statusResult.totals, exitCode: statusResult.exitCode },
     }, null, 2) + '\n');
+    if (statusResult.exitCode !== 0) process.exitCode = statusResult.exitCode;
   } else {
     console.log(chalk.green(`\n  v Saved ${block.models.length} model(s) to ${routerPath}:`));
     console.log(chalk.dim(`    Models.dev profiles: ${Object.keys(block.profiles || {}).length}/${block.models.length}`));
@@ -1930,6 +2130,20 @@ export async function run(name, args, isHelpRequest, deps = {}) {
     if (picker.wrote) {
       console.log(chalk.dim(`    /model picker populated with ${picker.options.length} entr${picker.options.length === 1 ? 'y' : 'ies'}`));
     }
+    // 10.19.9 Phase 3: post-confirm status screen. Prints one ✔ / ✖ / ⤳
+    // row per picked id + an `N passed, M failed, K skipped` footer when
+    // stdout is a TTY, or a single collapsed line when piped. Empty-pick
+    // (the `picked.length === 0` branch above) intentionally skips the
+    // screen — the chalk.yellow "No models selected" line is the only
+    // operator feedback there.
+    const statusResult = renderPickStatusScreen({
+      picked,
+      profiles: profilesMap,
+      preExisting,
+      out: process.stdout,
+      isTTY: !!process.stdout.isTTY,
+    });
+    if (statusResult.exitCode !== 0) process.exitCode = statusResult.exitCode;
   }
   return true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.20.0",
+  "version": "10.20.1",
   "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-sdk",
-  "version": "10.20.0",
+  "version": "10.20.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",