@polderlabs/bizar 10.17.3 → 10.18.0

package/cli/bin.mjs

@@ -117,7 +117,6 @@ function showHelp() {
     claim <subcommand>     GitHub-style claim protocol over feature_list.json
     task <subcommand>      Durable dependency/worktree/path task coordination
     control <subcommand>   Machine-readable agents/tasks/sessions/messages API
-    picker-proxy <start>   Run the 9router picker proxy (default port 20129)
     workflow <subcommand>  Session-bound autopilot workflow state
     hook <name>            Run a portable Claude Code hook
     worktree-merge <branch>  Merge a feature branch with archive tag (no work lost)
@@ -448,6 +447,22 @@ async function main() {
       break;
     }
 
+    case 'improve': {
+      const mod = await importCommand('improve');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load improve command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'improve');
+      const found = await mod.run(cmd, cmdArgs, isHelpRequest);
+      if (found === false) {
+        console.error(chalk.red(`  ✗ Usage: bizar improve <subcommand> — run 'bizar improve --help'`));
+        process.exit(EXIT_USAGE);
+      }
+      break;
+    }
+
     case 'model': {
       // Deprecated alias. Routes to the original `model.mjs` so the
       // legacy JSON shape (`{ providers: { ... }, total: N }`) and table
@@ -500,11 +515,7 @@ async function main() {
       break;
     }
 
-    case 'picker-proxy': {
-      await import('./commands/picker-proxy.mjs');
-      return;
-    }
-
+    
     case 'worktree-merge': {
       await import('./commands/worktree-merge.mjs');
       return;

package/cli/commands/evidence-bundles.mjs

@@ -0,0 +1,239 @@
+/**
+ * cli/commands/evidence-bundles.mjs — F-194 typed EvidenceBundle ledger.
+ *
+ * This is the durable on-disk store for typed `EvidenceBundle` records
+ * (the observation that fills in an `ObjectiveRun`). It lives next to
+ * the F-191 dispatch.jsonl ledger inside the same `~/.config/bizar/evidence/`
+ * directory but uses a distinct per-run filename:
+ *
+ *   ~/.config/bizar/evidence/<objectiveRunId>.jsonl   one EvidenceBundle per line
+ *   ~/.config/bizar/evidence/signatures.bundle       aggregate signature manifest
+ *
+ * Why a separate ledger file (and not the F-191 dispatch.jsonl):
+ *   - F-191 is per-routing-decision (one row per dispatched model call).
+ *   - F-194 is per-objective-run (typed observation after a real shell
+ *     command ran, with command/cwd/exit/tests/revisions/sha256).
+ *   - Same directory keeps mode=0o700 trivial; distinct filenames keep
+ *     the two writers from racing on the same append handle.
+ *
+ * Why mode=0o700:
+ *   - The bundle contents reveal operator-side git revisions,
+ *     evaluator/rubric hashes, exit codes, token usage, and (via the
+ *     eval digest) potentially sensitive environment fingerprints.
+ *   - Only the operator should read them.
+ *
+ * Invariants:
+ *   - `evidenceDir` is created lazily with mode `0o700`.
+ *   - Each `appendBundle` call appends exactly one JSON line to the
+ *     run's JSONL file and updates `signatures.bundle`.
+ *   - `verifyBundles` MUST return `{ ok: true }` for any ledger produced
+ *     by this module + the matching secret, and `{ ok: false, reason }`
+ *     for any tampered row or missing manifest entry.
+ */
+
+import { createHash } from 'node:crypto';
+import {
+  existsSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+  appendFileSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { verifyBundleSignature } from '../../packages/sdk/dist/autonomy/evidence-bundle.js';
+import {
+  ensureSecureDir,
+  resolveSecureSubdir,
+  SECURE_DIR_MODE,
+} from './secure-dir.mjs';
+
+/** Mode applied to the evidence directory and to every JSONL row file. */
+export const EVIDENCE_DIR_MODE = SECURE_DIR_MODE;
+
+/** Name of the per-run JSONL file when not provided. */
+export const SIGNATURES_BUNDLE = 'signatures.bundle';
+
+/**
+ * Resolve the evidence directory with the precedence:
+ *   1. `BIZAR_EVIDENCE_DIR` env (absolute or cwd-relative).
+ *   2. `BIZAR_HOME/evidence` (BIZAR_HOME resolved the same way as provision.mjs).
+ *   3. `~/.config/bizar/evidence` (XDG fallback).
+ */
+export function resolveEvidenceDir({ cwd = process.cwd(), env = process.env } = {}) {
+  return resolveSecureSubdir({
+    cwd, env,
+    envOverride: 'BIZAR_EVIDENCE_DIR',
+    envSubdir: 'BIZAR_HOME',
+    subdir: 'evidence',
+  });
+}
+
+/** Create the evidence dir if missing. Idempotent. Returns the path. */
+export function ensureEvidenceDir({ cwd = process.cwd(), env = process.env } = {}) {
+  return ensureSecureDir({
+    cwd, env,
+    envOverride: 'BIZAR_EVIDENCE_DIR',
+    envSubdir: 'BIZAR_HOME',
+    subdir: 'evidence',
+    mode: EVIDENCE_DIR_MODE,
+  });
+}
+
+/** Path to a single run's JSONL file. */
+export function bundleJsonlPath({ objectiveRunId, evidenceDir }) {
+  if (typeof objectiveRunId !== 'string' || objectiveRunId.length === 0) {
+    throw new TypeError('bundleJsonlPath: objectiveRunId must be a non-empty string');
+  }
+  // Sanitize: reject path separators + traversal.
+  if (!/^[a-zA-Z0-9._-]+$/.test(objectiveRunId)) {
+    throw new TypeError(`bundleJsonlPath: objectiveRunId has unsafe characters: ${objectiveRunId}`);
+  }
+  return join(evidenceDir, `${objectiveRunId}.jsonl`);
+}
+
+/** Path to the signatures.bundle aggregate file. */
+export function signaturesBundlePath({ evidenceDir }) {
+  return join(evidenceDir, SIGNATURES_BUNDLE);
+}
+
+/**
+ * Append one signed EvidenceBundle to its run's JSONL file and
+ * record its signature into signatures.bundle.
+ *
+ * Returns `{ ok: true, path, signature, recordedAt }`.
+ *
+ * Throws if `verifyBundleSignature(bundle, secret)` is false.
+ */
+export function appendBundle({ bundle, secret, evidenceDir }) {
+  if (!bundle || typeof bundle !== 'object') {
+    throw new TypeError('appendBundle: bundle must be an object');
+  }
+  if (typeof secret !== 'string' || secret.length === 0) {
+    throw new TypeError('appendBundle: secret must be a non-empty string');
+  }
+  // Validate objectiveRunId first so path-traversal can't sneak a row
+  // past the signature gate via a different error message.
+  bundleJsonlPath({ objectiveRunId: bundle.objectiveRunId, evidenceDir: evidenceDir ?? resolveEvidenceDir() });
+  const dir = ensureEvidenceDir({ env: { ...process.env, BIZAR_EVIDENCE_DIR: evidenceDir } });
+  if (!verifyBundleSignature(bundle, secret)) {
+    throw new Error('appendBundle: bundle signature failed verification (wrong secret or tampered row)');
+  }
+  const path = bundleJsonlPath({ objectiveRunId: bundle.objectiveRunId, evidenceDir: dir });
+  const line = JSON.stringify(bundle) + '\n';
+  appendFileSync(path, line, { mode: EVIDENCE_DIR_MODE });
+  const recordedAt = new Date().toISOString();
+  const sigPath = signaturesBundlePath({ evidenceDir: dir });
+  let sigs = {};
+  if (existsSync(sigPath)) {
+    try { sigs = JSON.parse(readFileSync(sigPath, 'utf8')); } catch { sigs = {}; }
+  }
+  const runSigs = Array.isArray(sigs[bundle.objectiveRunId]) ? sigs[bundle.objectiveRunId] : [];
+  runSigs.push({
+    bundleId: bundle.bundleId,
+    signature: bundle.signature,
+    recordedAt,
+    sha256BundleLine: createHash('sha256').update(line).digest('hex'),
+  });
+  sigs[bundle.objectiveRunId] = runSigs;
+  writeFileSync(sigPath, JSON.stringify(sigs, null, 2) + '\n', { mode: EVIDENCE_DIR_MODE });
+  return { ok: true, path, signature: bundle.signature, recordedAt };
+}
+
+/**
+ * List every per-run JSONL in the evidence dir, with row counts and
+ * last-appended timestamp. Excludes `signatures.bundle` itself.
+ */
+export function listBundles(opts = {}) {
+  const dir = opts.evidenceDir ?? resolveEvidenceDir();
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith('.jsonl')) continue;
+    const path = join(dir, entry.name);
+    const objectiveRunId = entry.name.slice(0, -'.jsonl'.length);
+    const raw = readFileSync(path, 'utf8');
+    const lines = raw.split('\n').filter((l) => l.trim().length > 0);
+    let lastAppendedAt = null;
+    if (lines.length > 0) {
+      try {
+        const last = JSON.parse(lines[lines.length - 1]);
+        lastAppendedAt = last.createdAt ?? null;
+      } catch { /* ignore */ }
+    }
+    out.push({
+      objectiveRunId,
+      path,
+      rowCount: lines.length,
+      lastAppendedAt,
+    });
+  }
+  out.sort((a, b) => a.objectiveRunId.localeCompare(b.objectiveRunId));
+  return out;
+}
+
+/**
+ * Re-verify every signed bundle in every run's JSONL file, then
+ * cross-check the signatures.bundle manifest. Returns:
+ *   - `{ ok: true, verifiedRuns, totalRows }` on success.
+ *   - `{ ok: false, reason, runId?, bundleId? }` on any mismatch.
+ *
+ * `reason` is a stable machine-readable string for scripting.
+ */
+export function verifyBundles(opts = {}) {
+  const { secret, evidenceDir } = opts;
+  if (typeof secret !== 'string' || secret.length === 0) {
+    throw new TypeError('verifyBundles: secret must be a non-empty string');
+  }
+  const dir = evidenceDir ?? resolveEvidenceDir();
+  if (!existsSync(dir)) {
+    return { ok: false, reason: 'evidence-dir-missing' };
+  }
+  const entries = listBundles({ evidenceDir: dir });
+  let totalRows = 0;
+  for (const { objectiveRunId, path } of entries) {
+    const lines = readFileSync(path, 'utf8').split('\n').filter((l) => l.trim().length > 0);
+    for (const line of lines) {
+      totalRows += 1;
+      let row;
+      try { row = JSON.parse(line); } catch {
+        return { ok: false, reason: 'malformed-jsonl-line', runId: objectiveRunId };
+      }
+      if (!verifyBundleSignature(row, secret)) {
+        return {
+          ok: false,
+          reason: 'bundle-signature-mismatch',
+          runId: objectiveRunId,
+          bundleId: row.bundleId,
+        };
+      }
+    }
+  }
+  // Cross-check the aggregate manifest if present.
+  const sigPath = signaturesBundlePath({ evidenceDir: dir });
+  if (existsSync(sigPath)) {
+    let manifest;
+    try { manifest = JSON.parse(readFileSync(sigPath, 'utf8')); }
+    catch { return { ok: false, reason: 'signatures-bundle-malformed' }; }
+    for (const [runId, sigs] of Object.entries(manifest)) {
+      if (!Array.isArray(sigs)) {
+        return { ok: false, reason: 'signatures-bundle-shape', runId };
+      }
+      const runFile = join(dir, `${runId}.jsonl`);
+      if (!existsSync(runFile)) {
+        return { ok: false, reason: 'signatures-bundle-orphan', runId };
+      }
+      const lines = readFileSync(runFile, 'utf8').split('\n').filter((l) => l.trim().length > 0);
+      if (sigs.length !== lines.length) {
+        return {
+          ok: false,
+          reason: 'signatures-bundle-count-mismatch',
+          runId,
+          manifestCount: sigs.length,
+          jsonlCount: lines.length,
+        };
+      }
+    }
+  }
+  return { ok: true, verifiedRuns: entries.length, totalRows };
+}

package/cli/commands/evidence.mjs

@@ -316,6 +316,98 @@ function handleAudit(args) {
   return report.missingOutcome.length === 0 && report.mismatched.length === 0 ? 0 : 1;
 }
 
+// ── F-194 typed EvidenceBundle subcommands ───────────────────────────────────
+//
+// `bizar evidence append --file <bundle.json>`  append a signed bundle to its run JSONL
+// `bizar evidence list`                          list every per-run JSONL with row counts
+// `bizar evidence verify-bundles`                re-verify every signed bundle + manifest
+//
+// These commands consume the typed EvidenceBundle ledger kept under
+// `~/.config/bizar/evidence/<objectiveRunId>.jsonl` + `signatures.bundle`.
+// They are deliberately distinct from the F-191 subcommands above so the
+// two ledgers do not race on the same append handle.
+
+import {
+  appendBundle,
+  listBundles,
+  verifyBundles,
+} from './evidence-bundles.mjs';
+
+function readSecret() {
+  return process.env.BIZAR_EVIDENCE_SECRET
+    || process.env.BIZAR_AUTONOMY_SECRET
+    || '';
+}
+
+function handleAppend(args) {
+  const fileArg = args.find((a) => a.startsWith('--file='))?.slice('--file='.length);
+  const fileFlag = args.includes('--file');
+  const fileIdx = fileFlag ? args.indexOf('--file') + 1 : -1;
+  const filePath = fileArg || (fileIdx > 0 ? args[fileIdx] : null);
+  if (!filePath) {
+    console.error(chalk.red('  ✗ bizar evidence append requires --file <path-to-bundle.json>'));
+    return 2;
+  }
+  const secret = readSecret();
+  if (!secret) {
+    console.error(chalk.red('  ✗ set BIZAR_EVIDENCE_SECRET (or BIZAR_AUTONOMY_SECRET) before appending bundles'));
+    return 2;
+  }
+  let bundle;
+  try {
+    const raw = readFileSync(filePath, 'utf8');
+    bundle = JSON.parse(raw);
+  } catch (err) {
+    console.error(chalk.red(`  ✗ could not parse ${filePath}: ${err.message}`));
+    return 2;
+  }
+  try {
+    const result = appendBundle({ bundle, secret });
+    console.log(chalk.green(`  ✓ appended bundleId=${bundle.bundleId} → ${result.path}`));
+    return 0;
+  } catch (err) {
+    console.error(chalk.red(`  ✗ append failed: ${err.message}`));
+    return 1;
+  }
+}
+
+function handleList(args) {
+  const wantJson = args.includes('--json');
+  const rows = listBundles();
+  if (wantJson) {
+    process.stdout.write(JSON.stringify(rows, null, 2) + '\n');
+    return 0;
+  }
+  if (rows.length === 0) {
+    console.log(chalk.yellow('  ! no per-run evidence JSONL files yet'));
+    return 0;
+  }
+  for (const r of rows) {
+    console.log(`${chalk.cyan(r.objectiveRunId)}  rows=${r.rowCount}  last=${r.lastAppendedAt ?? '(unknown)'}`);
+  }
+  return 0;
+}
+
+function handleVerifyBundles(args) {
+  const wantJson = args.includes('--json');
+  const secret = readSecret();
+  if (!secret) {
+    console.error(chalk.red('  ✗ set BIZAR_EVIDENCE_SECRET (or BIZAR_AUTONOMY_SECRET) before verifying'));
+    return 2;
+  }
+  const result = verifyBundles({ secret });
+  if (wantJson) {
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    return result.ok ? 0 : 1;
+  }
+  if (!result.ok) {
+    console.error(chalk.red(`  ✗ verify-bundles failed: ${result.reason}${result.runId ? ` (run=${result.runId})` : ''}`));
+    return 1;
+  }
+  console.log(chalk.green(`  ✓ ${result.verifiedRuns} run(s), ${result.totalRows} bundle(s) verified`));
+  return 0;
+}
+
 // ── run() entrypoint ─────────────────────────────────────────────────────────
 
 export async function run(name, args, isHelpRequest) {
@@ -347,6 +439,15 @@ export async function run(name, args, isHelpRequest) {
     case 'audit':
       process.exit(handleAudit(rest));
       return true;
+    case 'append':
+      process.exit(handleAppend(rest));
+      return true;
+    case 'list':
+      process.exit(handleList(rest));
+      return true;
+    case 'verify-bundles':
+      process.exit(handleVerifyBundles(rest));
+      return true;
     default:
       console.error(chalk.red(`  ✗ unknown evidence subcommand: ${sub}`));
       showHelp();

package/cli/commands/improve-proposal.mjs

@@ -0,0 +1,155 @@
+/**
+ * cli/commands/improve-proposal.mjs — F-194 Phase C bounded self-edit
+ * proposal schema.
+ *
+ * A Proposal captures one shippable tweak Bizar can apply to itself
+ * (or to a config file the operator owns) with a verifiable audit trail.
+ *
+ * Why find/replace instead of a unified diff:
+ *   - Unified diffs have format ambiguity (hunk counts, trailing whitespace,
+ *     line-ending preservation). The hunk applies or doesn't.
+ *   - `find` is the verbatim byte-substring that must exist in the file
+ *     exactly once at apply time. If it appears zero times or more than
+ *     once, the apply MUST refuse — silent multi-replace is the kind of
+ *     regression that turns self-improvement into self-corruption.
+ *   - Rollback is a one-line `replace(find, newText)` call: `find` was
+ *     the pre-state, `newText` was the post-state, so reversing is the
+ *     same find+replace in the opposite direction.
+ *
+ * `id` is server-stamped at `propose` time so two proposals never share
+ * an identifier. `createdAt` is server-stamped too, so a replayed proposal
+ * carries its origin timestamp.
+ *
+ * Mode:
+ *   - `dryRun: true` → `bizar improve run` shows the diff + verification
+ *     plan + asks for confirmation, but does NOT mutate the target.
+ *   - `dryRun: false` → applies the change, runs the verification command,
+ *     appends an EvidenceBundle row on success. On verification failure
+ *     the apply is rolled back and a separate EvidenceBundle row records
+ *     the failure.
+ */
+
+import { createHash } from 'node:crypto';
+
+/** @typedef {{
+ *   id: string,
+ *   targetFile: string,
+ *   originalSha256: string,
+ *   find: string,
+ *   newText: string,
+ *   verification: { command: string, cwd?: string, timeoutMs?: number, expectedExitCode?: number },
+ *   rollbackPlan: { kind: 'replace-back', note: string } | { kind: 'manual', note: string, manualCommand?: string },
+ *   reason: string,
+ *   createdAt: string,
+ *   dryRun?: boolean,
+ * }} Proposal
+ */
+
+/** Frozen FORBIDDEN proposal keys — anything that smells like prompt or
+ *  raw bytes-of-the-target leaks operator content. Mirrors the F-194
+ *  BehaviorRecord policy so a regression cannot start persisting
+ *  decision-context to disk. */
+export const FORBIDDEN_PROPOSAL_KEYS = ['prompt', 'promptRedacted', 'rawPrompt', 'promptText', 'userInput', 'rawInput', 'rawInputBytes'];
+
+const PROPOSAL_KEYS = ['id', 'targetFile', 'originalSha256', 'find', 'newText', 'verification', 'rollbackPlan', 'reason', 'createdAt', 'dryRun'];
+
+/**
+ * @param {string} text
+ * @returns {string} sha256 hex of `text`
+ */
+export function sha256Text(text) {
+  return createHash('sha256').update(Buffer.from(text, 'utf8')).digest('hex');
+}
+
+/**
+ * @param {string} targetFile
+ * @param {string} cwd
+ * @returns {string} unique proposal id for this apply window
+ */
+export function newProposalId({ targetFile, cwd }) {
+  const seed = `${Date.now()}|${process.pid}|${targetFile}|${cwd}`;
+  return `imp-${sha256Text(seed).slice(0, 12)}`;
+}
+
+/**
+ * @param {object} raw
+ * @returns {Proposal}
+ */
+export function validateProposal(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new TypeError('Proposal must be an object');
+  }
+  for (const k of Object.keys(raw)) {
+    if (FORBIDDEN_PROPOSAL_KEYS.includes(k)) {
+      throw new TypeError(`Proposal must not contain forbidden key: ${k}`);
+    }
+    if (!PROPOSAL_KEYS.includes(k)) {
+      throw new TypeError(`Proposal has unknown key: ${k}`);
+    }
+  }
+  for (const required of ['targetFile', 'originalSha256', 'find', 'newText', 'verification', 'rollbackPlan', 'reason']) {
+    if (typeof raw[required] !== 'string' && typeof raw[required] !== 'object') {
+      throw new TypeError(`Proposal.${required} is required and must be string or object`);
+    }
+  }
+  if (raw.find.length === 0) {
+    throw new TypeError('Proposal.find must be a non-empty substring');
+  }
+  if (raw.find === raw.newText) {
+    throw new TypeError('Proposal.newText must differ from Proposal.find');
+  }
+  if (typeof raw.verification !== 'object' || typeof raw.verification.command !== 'string' || raw.verification.command.length === 0) {
+    throw new TypeError('Proposal.verification.command must be a non-empty string');
+  }
+  if (typeof raw.rollbackPlan !== 'object' || (raw.rollbackPlan.kind !== 'replace-back' && raw.rollbackPlan.kind !== 'manual')) {
+    throw new TypeError('Proposal.rollbackPlan.kind must be "replace-back" or "manual"');
+  }
+  return /** @type {Proposal} */ (raw);
+}
+
+/**
+ * Apply a Proposal to the target file's current bytes. Refuses if:
+ *   - `originalSha256` does not match the file's current sha256 (file changed since propose)
+ *   - `find` does not appear exactly once in the file
+ *
+ * @param {Proposal} proposal
+ * @param {string} currentFileBytes  UTF-8 text of the target file as it stands now
+ * @returns {{ ok: true, newBytes: string, originalBytes: string } | { ok: false, reason: string }}
+ */
+export function planApply(proposal, currentFileBytes) {
+  const currentSha = sha256Text(currentFileBytes);
+  if (currentSha !== proposal.originalSha256) {
+    return { ok: false, reason: `target sha256 drift: expected ${proposal.originalSha256}, got ${currentSha}` };
+  }
+  let count = 0;
+  let idx = 0;
+  while ((idx = currentFileBytes.indexOf(proposal.find, idx)) !== -1) {
+    count += 1;
+    idx += proposal.find.length;
+  }
+  if (count !== 1) {
+    return { ok: false, reason: `Proposal.find matched ${count} times in target; expected exactly 1` };
+  }
+  const newBytes = currentFileBytes.replace(proposal.find, proposal.newText);
+  const newSha = sha256Text(newBytes);
+  if (newSha === currentSha) {
+    return { ok: false, reason: 'Proposal.apply produced no change (find == newText after canonicalization)' };
+  }
+  return { ok: true, newBytes, originalBytes: currentFileBytes };
+}
+
+/**
+ * Compute the rollback bytes for a Proposal. For `replace-back` this is
+ * the original bytes (already captured by planApply). For `manual`, the
+ * caller is responsible for executing `manualCommand`.
+ *
+ * @param {Proposal} proposal
+ * @param {string} currentBytes post-apply file bytes
+ * @returns {{ kind: 'replace-back', newBytes: string } | { kind: 'manual', manualCommand?: string }}
+ */
+export function planRollback(proposal, currentBytes) {
+  if (proposal.rollbackPlan.kind === 'replace-back') {
+    return { kind: 'replace-back', newBytes: currentBytes.replace(proposal.newText, proposal.find) };
+  }
+  return { kind: 'manual', manualCommand: proposal.rollbackPlan.manualCommand };
+}