@polderlabs/bizar 10.19.3 → 10.19.5

package/cli/commands/hook.mjs

@@ -40,6 +40,7 @@ export const HOOK_PROGRAMS = Object.freeze({
   'pretooluse-bash': 'pretooluse-bash.mjs',
   'pretooluse-editwrite': 'pretooluse-editwrite.mjs',
   'sessionend-recall': 'sessionend-recall.mjs',
+  'sessionstart-model-sync': 'sessionstart-model-sync.mjs',
   'sessionstart-prime': 'sessionstart-prime.mjs',
   'simplify-guard': 'simplify-guard.mjs',
   telemetry: 'telemetry.mjs',
@@ -61,6 +62,7 @@ export const EVENT_CHAINS = Object.freeze({
   ]),
   'session-start': Object.freeze([
     'control-inbox',
+    'sessionstart-model-sync',
     'sessionstart-prime',
     'persistent-mode',
     'telemetry',

package/cli/commands/models.mjs

@@ -634,23 +634,23 @@ export function deriveModelLabel(modelId, profile) {
 }
 
 /**
- * Sync `userSelected.models` into Claude Code's `modelPicker` array
+ * Sync `userSelected.models` into Claude Code's `modelPicker` setting
  * (settings.json). The picker is what populates `/model` — `modelOverrides`
  * alone only silences diagnostics, it does NOT add entries to the picker.
  *
- * Per Claude Code's settings reference: `modelPicker` is an array of
- * `{ id, label }` entries that replaces the gateway-discovered picker
- * contents. Scope is User-or-managed (settings.json is in scope). Each
- * entry preserves the operator's pick order from `userSelected.models`.
+ * Per Claude Code's settings reference: `modelPicker` is an OBJECT with an
+ * `options` array. Each option has `{ model, label?, description? }`.
+ * Scope is User-or-managed (settings.json is in scope). The `options`
+ * array preserves the operator's pick order from `userSelected.models`.
  *
  * Behavior:
  *   - Reads settings.json; preserves every other field (env, mcpServers,
  *     permissions, hooks, etc.).
- *   - Writes `modelPicker` as an array of `{ id, label }`.
+ *   - Writes `modelPicker = { options: [{ model, label }] }`.
  *   - Filters out picks the live gateway rejects (same stale-ID contract as
  *     `applyModelOverrides`); the surviving picks fill the picker.
- *   - Empty pick list → writes `modelPicker: []` so the picker falls back
- *     to whatever Claude Code's defaults surface.
+ *   - Empty pick list → writes `modelPicker: { options: [] }` so Claude
+ *     Code falls back to its built-in picker.
  *   - Atomic replace via temp-file + rename (matches `applyModels`).
  *   - Refuses to overwrite a corrupt settings.json.
  *   - When `settingsJsonPath === null`, returns a no-op (tests).
@@ -663,7 +663,7 @@ export function deriveModelLabel(modelId, profile) {
  * }} opts
  * @returns {{
  *   wrote: boolean,
- *   entries: Array<{id: string, label: string}>,
+ *   options: Array<{model: string, label: string, description?: string}>,
  *   skippedStale: string[],
  *   settingsPath: string|null,
  * }}
@@ -673,13 +673,20 @@ export function applyModelPicker({ settingsJsonPath, pickedIds, profiles = {}, l
     ? join(homedir(), '.claude', 'settings.json')
     : settingsJsonPath;
   if (path === null) {
-    return { wrote: false, entries: [], skippedStale: [], settingsPath: null };
+    return { wrote: false, options: [], skippedStale: [], settingsPath: null };
   }
   const live = new Set(Array.isArray(liveIds) ? liveIds : []);
   const picks = Array.isArray(pickedIds) ? pickedIds.filter((id) => typeof id === 'string' && id.trim()) : [];
   const surviving = live.size === 0 ? picks : picks.filter((id) => live.has(id));
   const skipped = live.size === 0 ? [] : picks.filter((id) => !live.has(id));
-  const entries = surviving.map((id) => ({ id, label: deriveModelLabel(id, profiles?.[id]) }));
+  const options = surviving.map((id) => {
+    const profile = profiles?.[id];
+    const label = deriveModelLabel(id, profile);
+    const option = { model: id, label };
+    const description = profile && typeof profile.description === 'string' && profile.description.trim();
+    if (description) option.description = description.trim();
+    return option;
+  });
 
   let settings = {};
   if (existsSync(path)) {
@@ -687,12 +694,12 @@ export function applyModelPicker({ settingsJsonPath, pickedIds, profiles = {}, l
       const parsed = JSON.parse(readFileSync(path, 'utf8'));
       if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) settings = parsed;
     } catch {
-      return { wrote: false, entries: [], skippedStale: skipped, settingsPath: path };
+      return { wrote: false, options: [], skippedStale: skipped, settingsPath: path };
     }
   }
-  settings.modelPicker = entries;
+  settings.modelPicker = { options };
   writeAtomic(path, JSON.stringify(settings, null, 2) + '\n');
-  return { wrote: true, entries, skippedStale: skipped, settingsPath: path };
+  return { wrote: true, options, skippedStale: skipped, settingsPath: path };
 }
 
 // ── F-190 / IMP-017 refresh + operator-override preservation ────────────────
@@ -1654,7 +1661,7 @@ export async function run(name, args, isHelpRequest) {
       console.log(chalk.yellow(`    Settings sync skipped ${sync.skippedStale.length} stale id(s): ${sync.skippedStale.join(', ')}`));
     }
     if (picker.wrote) {
-      console.log(chalk.dim(`    /model picker populated with ${picker.entries.length} entr${picker.entries.length === 1 ? 'y' : 'ies'}`));
+      console.log(chalk.dim(`    /model picker populated with ${picker.options.length} entr${picker.options.length === 1 ? 'y' : 'ies'}`));
     }
   }
   return true;

package/config/claude/hooks/sessionstart-model-sync.mjs

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+/**
+ * sessionstart-model-sync.mjs — Claude Code SessionStart hook.
+ *
+ * Re-applies the operator's `userSelected.models` block (from
+ * `~/.config/bizar/config/claude/model-router.json`) into the three
+ * Claude Code settings keys that the operator owns:
+ *
+ *   - modelPicker   → { options: [{ model, label }] } in user pick order
+ *   - modelOverrides → { <id>: <id> } self-map for every live pick
+ *   - model         → reset to the first user pick if the current value
+ *                     starts with `claude-` (the dead gateway namespace —
+ *                     the live gateway rejects it with model_not_found)
+ *
+ * Why this hook exists:
+ *   Claude Code's `/model` picker rewrites `~/.claude/settings.json` on
+ *   every user pick. The rewrite preserves most keys but drops `modelPicker`
+ *   and rewrites `model` to whatever the gateway returned (often the dead
+ *   `claude-<provider>/<model>[1m]` shape). Without this hook the operator
+ *   loses their picker list between every Claude Code session.
+ *
+ * Scope guarantee:
+ *   This hook ONLY touches `modelPicker`, `modelOverrides`, and `model`.
+ *   Env, mcpServers, permissions, hooks, and every other operator key is
+ *   left untouched. The source of truth for picks
+ *   (`~/.config/bizar/config/claude/model-router.json`) is also untouched.
+ *
+ * Failure policy:
+ *   This is an advisory hook. Any failure (missing router, malformed JSON,
+ *   unwritable settings.json, etc.) is logged to
+ *   `~/.config/bizar/hook-logs/model-sync-DATE.jsonl` and swallowed. The
+ *   hook always exits 0 — the operator's existing picks survive whatever
+ *   Claude Code wrote last, and a broken sync must not block session start.
+ *
+ * Claude Code SessionStart input:
+ *   { session_id, transcript_path, cwd, hook_event_name, source }
+ *
+ * Claude Code SessionStart output:
+ *   { hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext } }
+ */
+
+'use strict';
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const HOOK_LOG_DIR = join(homedir(), '.config', 'bizar', 'hook-logs');
+
+function readJsonIfObject(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function readRouterPath() {
+  const envOverride = process.env.BIZAR_MODEL_ROUTER_CONFIG;
+  if (envOverride && typeof envOverride === 'string' && envOverride.trim()) {
+    return envOverride;
+  }
+  return join(homedir(), '.config', 'bizar', 'config', 'claude', 'model-router.json');
+}
+
+function readSettingsPath() {
+  return join(homedir(), '.claude', 'settings.json');
+}
+
+// Mirrors `cli/commands/models.mjs#deriveModelLabel` without the profile
+// override branch. The picker label is meant to be derived from the model
+// id; the profile `name`/`displayName` is used elsewhere in `applyModelPicker`
+// only when present, but for our session-start re-apply the id-derived label
+// is sufficient and matches the helper's behaviour for every live id in the
+// router file.
+function deriveModelLabel(modelId) {
+  const id = String(modelId || '').trim();
+  if (!id) return '';
+  const slash = id.indexOf('/');
+  const tail = slash >= 0 ? id.slice(slash + 1) : id;
+  return tail
+    .replace(/[\\/]+/g, ' ')
+    .replace(/[-_]+/g, ' ')
+    .replace(/:/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function atomicWriteJson(path, value) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n');
+  renameSync(tmp, path);
+}
+
+function logEvent(entry) {
+  try {
+    mkdirSync(HOOK_LOG_DIR, { recursive: true });
+    const today = new Date().toISOString().slice(0, 10);
+    appendFileSync(
+      join(HOOK_LOG_DIR, `model-sync-${today}.jsonl`),
+      JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n',
+    );
+  } catch {
+    /* best-effort */
+  }
+}
+
+function buildPayload(appliedCount, modelAfter) {
+  const note = appliedCount > 0
+    ? `Bizar reapplied ${appliedCount} model picker option(s) to ~/.claude/settings.json (model=${modelAfter}).`
+    : '';
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: note,
+    },
+  };
+}
+
+function syncOnce() {
+  const routerPath = readRouterPath();
+  const router = readJsonIfObject(routerPath);
+  const userSelected = router && typeof router === 'object' ? router.userSelected : null;
+  const models = userSelected && Array.isArray(userSelected.models) ? userSelected.models : [];
+  const profiles = userSelected && userSelected.profiles && typeof userSelected.profiles === 'object'
+    ? userSelected.profiles
+    : {};
+  const liveIds = models.filter((id) => typeof id === 'string' && id.trim());
+  if (liveIds.length === 0) {
+    return { applied: 0, modelAfter: null, skipped: 'no-userSelected' };
+  }
+
+  const settingsPath = readSettingsPath();
+  const settings = readJsonIfObject(settingsPath) || {};
+  const before = {
+    model: typeof settings.model === 'string' ? settings.model : null,
+    modelPicker: settings.modelPicker || null,
+    modelOverrides: settings.modelOverrides || null,
+  };
+
+  const options = liveIds.map((id) => {
+    const option = { model: id, label: deriveModelLabel(id) };
+    const profile = profiles[id];
+    if (profile && typeof profile.description === 'string' && profile.description.trim()) {
+      option.description = profile.description.trim();
+    }
+    return option;
+  });
+
+  settings.modelPicker = { options };
+  settings.modelOverrides = Object.fromEntries(liveIds.map((id) => [id, id]));
+
+  let modelChanged = false;
+  if (typeof settings.model === 'string' && settings.model.startsWith('claude-')) {
+    settings.model = liveIds[0];
+    modelChanged = true;
+  }
+
+  atomicWriteJson(settingsPath, settings);
+
+  const after = {
+    model: typeof settings.model === 'string' ? settings.model : null,
+    modelPickerOptions: options.length,
+    modelOverridesCount: Object.keys(settings.modelOverrides).length,
+    modelChanged,
+  };
+
+  logEvent({ event: 'sessionstart-model-sync', routerPath, before, after });
+  return { applied: options.length, modelAfter: after.model, modelChanged };
+}
+
+function run() {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { raw += chunk; });
+  process.stdin.on('end', () => {
+    let input = {};
+    try { input = JSON.parse(raw || '{}'); } catch { input = {}; }
+    const sessionId = String(input.session_id || '');
+    const source = String(input.source || 'startup');
+    try {
+      const result = syncOnce();
+      const payload = buildPayload(result.applied, result.modelAfter);
+      process.stdout.write(JSON.stringify(payload) + '\n');
+    } catch (err) {
+      logEvent({
+        event: 'sessionstart-model-sync-error',
+        sessionId: sessionId || null,
+        source,
+        error: err && err.message ? err.message : String(err),
+      });
+      // Advisory hook — never block session start on a sync failure.
+      process.stdout.write('{}\n');
+    }
+  });
+}
+
+run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.19.3",
+  "version": "10.19.5",
   "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/dist/version.d.ts

@@ -1,5 +1,5 @@
 /**
  * SDK version constant. Keep synchronized with the workspace package versions.
  */
-export declare const SDK_VERSION: "10.19.3";
+export declare const SDK_VERSION: "10.19.5";
 //# sourceMappingURL=version.d.ts.map

package/packages/sdk/dist/version.js

@@ -1,5 +1,5 @@
 /**
  * SDK version constant. Keep synchronized with the workspace package versions.
  */
-export const SDK_VERSION = "10.19.3";
+export const SDK_VERSION = "10.19.5";
 //# sourceMappingURL=version.js.map

package/packages/sdk/package.json

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