@polderlabs/bizar 10.17.1 → 10.17.3

package/cli/commands/hook.mjs

@@ -248,7 +248,7 @@ export function selectEventChain(eventKey, input = '') {
   if (eventKey === 'subagent-start') {
     return chain.filter((leaf) => {
       if (leaf === 'advisor-context') {
-        return /^(linda|karen|carl|qa-reviewer|principal-engineer|debug-specialist)$/.test(agentType);
+        return /^(linda|carl)$/.test(agentType);
       }
       if (leaf === 'worktree-bootstrap') {
         return /^(brad|carl|pam|brenda|karen|todd|ria)$/.test(agentType);

package/cli/commands/models.mjs

@@ -21,6 +21,7 @@ import chalk from 'chalk';
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
+import readline from 'node:readline';
 
 import {
   rankUserSelectedForRole as rankUserSelectedForRoleMirror,
@@ -732,12 +733,13 @@ export function explainSelection({ routerPath, role, requirements = {} } = {}) {
 /**
  * Interactive multi-select picker. Pure function over streams — testable.
  *
- * The picker prints candidates with current picks marked, accepts a space-
- * separated list of indices (or `all` / `none` / `toggle <i>`), and returns
- * the chosen IDs in the user's most-recent selection order.
- *
- * Non-TTY input (pipes, tests, CI) is supported via a simple async line
- * iterator; TTY input uses `rl.question` so the prompt stays interactive.
+ * Branching: when stdin is a TTY with raw-mode support, the picker drives a
+ * keypress-driven checklist (arrow keys / j-k / space / a / n / enter / q /
+ * esc / ?).  When stdin is not a TTY (pipes, CI, tests) the picker falls
+ * through to a line-mode loop that accepts a space-separated index list,
+ * `all`, `none`, `toggle <i>`, an empty line (confirm), or `q` (quit). Both
+ * branches return the chosen IDs in the user's most-recent selection order,
+ * so external callers and existing tests see a single `Promise<string[]>`.
  *
  * @param {{ candidates: Array<{ id: string }>, current?: string[], stdin?: NodeJS.ReadableStream, stdout?: NodeJS.WriteStream, prompt?: string }} opts
  * @returns {Promise<string[]>}
@@ -754,10 +756,36 @@ export async function pickModels({ candidates, current = [], stdin, stdout, prom
   const selected = new Set(current);
   let lastOrder = [...current];
 
-  const lines = makeLineReader(in$);
+  const useTty = in$.isTTY === true && typeof in$.setRawMode === 'function';
+  if (!useTty) {
+    return pickModelsLineMode({ ordered, candidates, selected, lastOrder, stdin: in$, stdout: out$, prompt });
+  }
+
+  // Try to enable raw mode. If that fails (rare — redirected TTY, broken
+  // pseudo-terminal), fall back to the line-mode picker so the user never
+  // sees a silent no-op.
+  let rawOk = true;
+  try {
+    in$.setRawMode(true);
+  } catch {
+    rawOk = false;
+  }
+  if (!rawOk) {
+    return pickModelsLineMode({ ordered, candidates, selected, lastOrder, stdin: in$, stdout: out$, prompt });
+  }
+
+  try {
+    return await pickModelsInteractive({ ordered, candidates, selected, lastOrder, stdin: in$, stdout: out$, prompt });
+  } finally {
+    try { in$.setRawMode(false); } catch { /* swallow — terminal may already be gone */ }
+  }
+}
+
+async function pickModelsLineMode({ ordered, candidates, selected, lastOrder, stdin, stdout, prompt }) {
+  const lines = makeLineReader(stdin);
   for (;;) {
-    renderPicker(out$, ordered, selected, prompt, candidates);
-    const line = await readPrompt(lines, out$, in$.isTTY === true, '> ');
+    renderPicker(stdout, ordered, selected, prompt, candidates);
+    const line = await readPrompt(lines, stdout, stdin.isTTY === true, '> ');
     if (line === null) break; // EOF on non-TTY
     const cmd = String(line || '').trim();
     if (cmd === '') break;
@@ -775,7 +803,7 @@ export async function pickModels({ candidates, current = [], stdin, stdout, prom
     if (cmd.startsWith('toggle ')) {
       const idx = Number(cmd.slice('toggle '.length).trim());
       if (!Number.isInteger(idx) || idx < 1 || idx > ordered.length) {
-        out$.write(chalk.red(`  x index out of range\n`));
+        stdout.write(chalk.red(`  x index out of range\n`));
         continue;
       }
       const id = ordered[idx - 1];
@@ -802,7 +830,7 @@ export async function pickModels({ candidates, current = [], stdin, stdout, prom
       }
       changed = true;
     }
-    if (!changed) out$.write(chalk.yellow(`  ! unrecognised input - try 'all', 'none', 'toggle <i>', or '1 3 5'\n`));
+    if (!changed) stdout.write(chalk.yellow(`  ! unrecognised input - try 'all', 'none', 'toggle <i>', or '1 3 5'\n`));
   }
   const seen = new Set();
   return lastOrder.filter((id) => {
@@ -813,6 +841,145 @@ export async function pickModels({ candidates, current = [], stdin, stdout, prom
   });
 }
 
+const VIEWPORT_SIZE = 20;
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const ERASE_SCREEN = '\x1b[2J\x1b[H';
+
+function cursorUp(n) {
+  return `\x1b[${n}A`;
+}
+
+function fitRow({ i, id, profile, width, isCursor, isSelected, columns }) {
+  const mark = isSelected ? chalk.green('[x]') : '[ ]';
+  const idx = String(i + 1).padStart(width, ' ');
+  const label = capabilityLabel(profile);
+  const budget = Math.max(40, (columns ?? 80) - 32);
+  const idText = id.length > budget ? `${id.slice(0, Math.max(1, budget - 1))}…` : id;
+  const cursorMark = isCursor ? chalk.inverse(' ▌ ') : '   ';
+  return `  ${cursorMark}${mark} ${chalk.dim(`${idx}.`)} ${idText}${chalk.dim(`  [${label}]`)}`;
+}
+
+async function pickModelsInteractive({ ordered, candidates, selected, lastOrder, stdin, stdout, prompt }) {
+  let cursor = 0;
+  let scrollTop = 0;
+  let lastRenderHeight = 0;
+  let showHelp = false;
+
+  readline.emitKeypressEvents(stdin);
+  if (typeof stdin.resume === 'function') stdin.resume();
+  stdout.write(`${ERASE_SCREEN}${HIDE_CURSOR}`);
+
+  const exitState = await new Promise((resolve) => {
+    const onKey = (str, key) => {
+      if (!key) return;
+      // Resolve confirmation
+      if (key.name === 'return' || str === 'q' || key.name === 'escape') {
+        return finish();
+      }
+      if (key.ctrl && key.name === 'c') {
+        // SIGINT: discard selection and break out, but do not bubble.
+        selected.clear();
+        lastOrder.length = 0;
+        return finish();
+      }
+      if (key.name === 'up' || str === 'k') {
+        cursor = (cursor - 1 + ordered.length) % ordered.length;
+      } else if (key.name === 'down' || str === 'j') {
+        cursor = (cursor + 1) % ordered.length;
+      } else if (key.name === 'space' || str === 'x') {
+        const id = ordered[cursor];
+        if (selected.has(id)) {
+          selected.delete(id);
+          lastOrder = lastOrder.filter((x) => x !== id);
+        } else {
+          selected.add(id);
+          lastOrder.push(id);
+        }
+      } else if (str === 'a') {
+        for (const id of ordered) selected.add(id);
+        lastOrder = [...ordered];
+      } else if (str === 'n') {
+        selected.clear();
+        lastOrder = [];
+      } else if (str === '?') {
+        showHelp = !showHelp;
+      } else {
+        return;
+      }
+      adjustScroll();
+      render();
+    };
+
+    const finish = () => {
+      stdin.removeListener('keypress', onKey);
+      if (typeof stdin.pause === 'function') stdin.pause();
+      resolve();
+    };
+
+    stdin.on('keypress', onKey);
+    render();
+  });
+
+  stdout.write(SHOW_CURSOR);
+
+  const seen = new Set();
+  return lastOrder.filter((id) => {
+    if (!selected.has(id)) return false;
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+
+  function adjustScroll() {
+    if (ordered.length <= VIEWPORT_SIZE) {
+      scrollTop = 0;
+      return;
+    }
+    if (cursor < scrollTop) scrollTop = cursor;
+    else if (cursor >= scrollTop + VIEWPORT_SIZE) scrollTop = cursor - VIEWPORT_SIZE + 1;
+    if (scrollTop < 0) scrollTop = 0;
+    if (scrollTop > Math.max(0, ordered.length - VIEWPORT_SIZE)) {
+      scrollTop = Math.max(0, ordered.length - VIEWPORT_SIZE);
+    }
+  }
+
+  function render() {
+    const width = String(ordered.length).length;
+    const columns = typeof stdout.columns === 'number' ? stdout.columns : 80;
+    const lines = [];
+    lines.push(`\x1b[K${chalk.bold(`-- ${prompt} --`)}`);
+    const start = scrollTop;
+    const end = Math.min(ordered.length, start + VIEWPORT_SIZE);
+    const above = start;
+    const below = ordered.length - end;
+    if (above > 0) lines.push(`\x1b[K${chalk.dim(`  ⋮ ${above} more above`)}`);
+    for (let i = start; i < end; i++) {
+      const profile = candidates.find((candidate) => candidate.id === ordered[i])?.profile;
+      const row = fitRow({
+        i,
+        id: ordered[i],
+        profile,
+        width,
+        isCursor: i === cursor,
+        isSelected: selected.has(ordered[i]),
+        columns,
+      });
+      lines.push(`\x1b[K${row}`);
+    }
+    if (below > 0) lines.push(`\x1b[K${chalk.dim(`  ⋮ ${below} more below`)}`);
+    lines.push(`\x1b[K${chalk.dim(`  ${selected.size}/${ordered.length} selected. ↑/↓ move · space toggle · a all · n none · enter confirm.`)}`);
+    if (showHelp) lines.push(`\x1b[K${chalk.dim(`  Extra: j/k · x toggle · q/esc confirm · ? help.`)}`);
+    lines.push(`\x1b[K`);
+
+    if (lastRenderHeight > 0) {
+      stdout.write(cursorUp(lastRenderHeight));
+    }
+    stdout.write(lines.join('\n'));
+    lastRenderHeight = lines.length;
+  }
+}
+
 /**
  * Build a small async iterator over `stdin` lines.
  * Returns null from `next()` when the stream ends.
@@ -909,7 +1076,7 @@ function showHelp() {
   bizar models - User-controlled model picker
 
   Usage:
-    bizar models                    Interactive picker (lists + asks for selection)
+    bizar models                    Interactive picker (TTY: arrow keys / space / enter; pipe: line-mode)
     bizar models --list             Print candidate IDs, one per line
     bizar models --set a,b,c        Persist the comma-separated IDs to userSelected
     bizar models --clear            Remove userSelected; orchestrator falls back to session-only

package/config/claude/hooks/advisor-context.mjs

@@ -1,43 +1,125 @@
 #!/usr/bin/env node
 /**
- * Inject the recent parent transcript into review-oriented subagents.
- * Reads newest-first with hard record and character caps.
+ * advisor-context.mjs — Claude Code SubagentStart leaf hook.
+ *
+ * Inject a SHORT, FILTERED slice of the parent transcript into reviewer /
+ * debug-specialist subagents (`@linda`, `@carl`). The previous version
+ * dumped up to 30kB of raw parent transcript on every dispatch of
+ * `linda|karen|carl|qa-reviewer|principal-engineer|debug-specialist`. Two
+ * failure modes followed:
+ *
+ *   1. The dump was too noisy — reviewers only need the recent intent
+ *      and the changed files, not arbitrary chitchat from earlier in
+ *      the session.
+ *   2. The JSONL transcript persists across sessions on the same
+ *      project (Claude Code appends to `~/.claude/projects/.../<id>.jsonl`
+ *      rather than rotating per session). Reading the "tail" of that
+ *      file can surface content from a previous, unrelated session —
+ *      including prior user prompts, spinner/status text, and stuff the
+ *      current session has no business knowing.
+ *
+ * The fix below:
+ *   - Take only the last 8 user/assistant records (was 60).
+ *   - Skip non-substantive records entirely: `isSidechain`, `isMeta`,
+ *     `type: 'attachment'`, `type: 'system'`, `type: 'last-prompt'`,
+ *     `type: 'ai-title'`, `type: 'agent-name'`,
+ *     `type: 'stop_hook_summary'`.
+ *   - Per-record cap: 800 chars (was 3000).
+ *   - Hard total cap: 6kB (was 30kB).
+ *   - Strip `<system-reminder>` and `<total_tokens>` blocks inside text
+ *     content.
+ *   - Fall back to "could not be reconstructed" when the dump is too
+ *     short to be useful (< 100 chars).
+ *
+ * Output envelope (unchanged from the previous version):
+ *   { hookSpecificOutput: { hookEventName: 'SubagentStart', additionalContext } }
  */
 
 import { readFileSync } from 'node:fs';
 
-const clip = (value, limit) => value.length > limit ? `${value.slice(0, limit)} …[truncated]` : value;
+const MAX_RECORDS = 8;
+const PER_RECORD_CAP = 800;
+const TOTAL_CAP = 6_000;
+const MIN_USEFUL_LENGTH = 100;
+
+// Records that should never be replayed as "parent context" — they are
+// bookkeeping, meta, or status output rather than substantive session
+// content.
+const SKIP_TYPES = new Set([
+  'attachment',
+  'system',
+  'last-prompt',
+  'ai-title',
+  'agent-name',
+  'stop_hook_summary',
+  'queue-operation',
+]);
+
+const SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+const TOTAL_TOKENS_RE = /<total_tokens>[\s\S]*?<\/total_tokens>/g;
+const CCR_RE = /\[\s*CCR\s+retrieve[^\]]*\]/g;
+
+function clip(value, limit) {
+  return value.length > limit ? `${value.slice(0, limit)} …[truncated]` : value;
+}
+
+function cleanText(text) {
+  if (typeof text !== 'string' || text.length === 0) return '';
+  return text
+    .replace(SYSTEM_REMINDER_RE, '')
+    .replace(TOTAL_TOKENS_RE, '')
+    .replace(CCR_RE, '[compacted context omitted]')
+    .replace(/[ \t]+\n/g, '\n')
+    .trim();
+}
+
+function isSubstantiveRecord(record) {
+  if (!record || typeof record !== 'object') return false;
+  if (record.isSidechain === true || record.isMeta === true) return false;
+  if (SKIP_TYPES.has(record.type)) return false;
+  return record.type === 'user' || record.type === 'assistant';
+}
+
+function extractText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((block) => block && block.type === 'text')
+    .map((block) => block.text || '')
+    .join('\n');
+}
+
+function readTranscriptLines(transcriptPath) {
+  if (!transcriptPath) return [];
+  let text;
+  try {
+    text = readFileSync(transcriptPath, 'utf8');
+  } catch {
+    return [];
+  }
+  return text.split('\n').filter(Boolean);
+}
 
 let input = {};
 try { input = JSON.parse(readFileSync(0, 'utf8') || '{}'); } catch { input = {}; }
 
-let rendered = [];
-try {
-  const lines = readFileSync(input.transcript_path, 'utf8').split('\n');
-  for (let index = lines.length - 1; index >= 0 && rendered.length < 60; index--) {
-    let record;
-    try { record = JSON.parse(lines[index]); } catch { continue; }
-    if (record.isSidechain || record.isMeta || !['user', 'assistant'].includes(record.type)) continue;
-    const content = record.message?.content;
-    if (typeof content === 'string') rendered.push(`${record.type}: ${clip(content, 3_000)}`);
-    else if (Array.isArray(content)) {
-      const text = content
-        .filter((block) => block?.type === 'text')
-        .map((block) => block.text || '')
-        .join('\n');
-      if (text) rendered.push(`${record.type}: ${clip(text, 3_000)}`);
-    }
-  }
-} catch { rendered = []; }
-
-rendered.reverse();
-let recent = rendered.join('\n\n---\n\n');
-if (recent.length > 30_000) recent = `…[older turns truncated]\n${recent.slice(-30_000)}`;
-// Strip CCR (context-compaction-retrieval) compression markers so subagents
-// do not interpret them as user content. Replace with a brief note.
-recent = recent.replace(/\[\s*CCR\s+retrieve[^\]]*\]/g, '[compacted context omitted]');
-const additionalContext = recent
-  ? `Review the caller's request against this recent parent-session evidence, not only its summary:\n\n<recent-conversation>\n${recent}\n</recent-conversation>`
+const lines = readTranscriptLines(input.transcript_path);
+const records = [];
+for (let index = lines.length - 1; index >= 0 && records.length < MAX_RECORDS; index--) {
+  let record;
+  try { record = JSON.parse(lines[index]); } catch { continue; }
+  if (!isSubstantiveRecord(record)) continue;
+  const text = cleanText(extractText(record.message?.content));
+  if (!text) continue;
+  records.push(`${record.type}: ${clip(text, PER_RECORD_CAP)}`);
+}
+
+records.reverse();
+let recent = records.join('\n\n---\n\n');
+if (recent.length > TOTAL_CAP) recent = `…[older turns truncated]\n${recent.slice(-TOTAL_CAP)}`;
+
+const additionalContext = recent.length >= MIN_USEFUL_LENGTH
+  ? `Recent parent transcript (last ${records.length} records, capped at ${TOTAL_CAP} chars):\n\n<recent-conversation>\n${recent}\n</recent-conversation>`
   : 'The parent transcript could not be reconstructed. State any context needed before making a strong claim.';
 
 process.stdout.write(JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.17.1",
+  "version": "10.17.3",
   "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.17.1";
+export declare const SDK_VERSION: "10.17.3";
 //# 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.17.1";
+export const SDK_VERSION = "10.17.3";
 //# sourceMappingURL=version.js.map

package/packages/sdk/package.json

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