@polderlabs/bizar 10.20.0 → 10.21.0

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/cli/commands/workflow-gc.mjs

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+/**
+ * cli/commands/workflow-gc.mjs — Phase B (v10.21.0) B.3
+ *
+ * Garbage-collects workflow run artifact directories under
+ * `<cwd>/.bizar/runs/`. Each run is a directory written by
+ * `config/workflows/lib/dispatch.js#writeArtifact` (B.1).
+ *
+ * Policy:
+ *   - TTL: 14 days since the directory's mtime (configurable via
+ *     `--max-age-days`).
+ *   - In-progress gate: if `feature_list.json` has any feature with
+ *     `state: in_progress`, NO directories are deleted (conservative;
+ *     we have no feature -> runId mapping). The dry-run reports this
+ *     explicitly so the operator sees the skip reason.
+ *   - Permission failures: skip + warn, never abort the run.
+ *   - Idempotent: re-running after a successful GC is a no-op.
+ *
+ * Usage:
+ *   node cli/commands/workflow-gc.mjs                 # real deletion
+ *   node cli/commands/workflow-gc.mjs --dry-run       # list only
+ *   node cli/commands/workflow-gc.mjs --max-age-days=7
+ *   node cli/commands/workflow-gc.mjs --root <path>   # override run root
+ *
+ * Exit codes:
+ *   0  success (every candidate either deleted or explicitly skipped)
+ *   1  at least one delete failed (dry-run is exit 0; the operator
+ *      reviews the per-row status and re-runs)
+ */
+import { existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(here, '..', '..');
+const dispatchPath = resolve(repoRoot, 'config', 'workflows', 'lib', 'dispatch.js');
+const dispatch = await import(pathToFileURL(dispatchPath).href);
+
+const { listRuns } = dispatch;
+
+const DEFAULT_MAX_AGE_DAYS = 14;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+function parseArgs(argv) {
+  const args = { dryRun: false, maxAgeDays: DEFAULT_MAX_AGE_DAYS, root: undefined };
+  for (const a of argv.slice(2)) {
+    if (a === '--dry-run') args.dryRun = true;
+    else if (a === '--help' || a === '-h') args.help = true;
+    else if (a.startsWith('--max-age-days=')) {
+      const n = Number(a.slice('--max-age-days='.length));
+      if (Number.isFinite(n) && n >= 0) args.maxAgeDays = n;
+    } else if (a.startsWith('--root=')) {
+      args.root = a.slice('--root='.length);
+    }
+  }
+  return args;
+}
+
+function printHelp() {
+  process.stdout.write(`workflow-gc — delete .bizar/runs/<run-id>/ older than N days.
+
+Usage:
+  node cli/commands/workflow-gc.mjs                  real deletion
+  node cli/commands/workflow-gc.mjs --dry-run        list candidates, no deletions
+  node cli/commands/workflow-gc.mjs --max-age-days=N  override the 14-day default TTL
+  node cli/commands/workflow-gc.mjs --root <path>    override the artifact root
+
+Exit codes:
+  0  success (every candidate either deleted or explicitly skipped)
+  1  at least one delete failed (operator reviews + re-runs)
+`);
+}
+
+/**
+ * Inspect feature_list.json#in_progress. Returns
+ * `{ inProgress: boolean, ids: string[] }`. When the file is missing
+ * or unreadable, inProgress is false (no gate) — a missing
+ * feature_list.json is not the GC tool's problem to fix.
+ */
+function inProgressFeatureIds(cwd) {
+  const p = resolve(cwd, 'feature_list.json');
+  if (!existsSync(p)) return { inProgress: false, ids: [] };
+  try {
+    const json = JSON.parse(readFileSync(p, 'utf8'));
+    const features = Array.isArray(json?.features) ? json.features : [];
+    const ids = features.filter((f) => f && f.state === 'in_progress').map((f) => f.id || '<no-id>');
+    return { inProgress: ids.length > 0, ids };
+  } catch {
+    return { inProgress: false, ids: [] };
+  }
+}
+
+/**
+ * Build a candidate list. Each row carries enough metadata for the
+ * dry-run output + the deletion loop:
+ *   { runId, path, ageDays, size, action: 'delete' | 'skip:<reason>' }
+ *
+ * Skip reasons:
+ *   'too-recent'      — mtime within the TTL window
+ *   'in-progress'     — feature_list.json has any in_progress feature
+ *   'permission-denied' — stat/rm threw EACCES or EPERM
+ *   'missing'         — directory vanished between listRuns() and stat()
+ */
+function planCandidates({ runs, nowMs, maxAgeDays, inProgress }) {
+  const out = [];
+  for (const run of runs) {
+    const ageDays = (nowMs - run.mtimeMs) / MS_PER_DAY;
+    if (inProgress) {
+      out.push({ runId: run.runId, path: run.path, ageDays, size: run.size, action: 'skip:in-progress' });
+      continue;
+    }
+    if (ageDays < maxAgeDays) {
+      out.push({ runId: run.runId, path: run.path, ageDays, size: run.size, action: 'skip:too-recent' });
+      continue;
+    }
+    out.push({ runId: run.runId, path: run.path, ageDays, size: run.size, action: 'delete' });
+  }
+  return out;
+}
+
+/**
+ * Execute the plan. Returns `{ rows, errors }` where `errors` is the
+ * list of (runId, message) pairs for failed deletions. Best-effort:
+ * every error is recorded but the loop continues so a single
+ * permission-denied directory does not block the rest of the sweep.
+ */
+function executePlan(rows, { dryRun, nowMs }) {
+  const errors = [];
+  const out = [];
+  for (const row of rows) {
+    if (row.action !== 'delete' || dryRun) {
+      out.push(row);
+      continue;
+    }
+    try {
+      rmSync(row.path, { recursive: true, force: true });
+      out.push({ ...row, deletedAt: new Date(nowMs).toISOString() });
+    } catch (err) {
+      const message = err && err.message ? err.message : String(err);
+      const reason = /EACCES|EPERM/.test(message) ? 'permission-denied' : 'unknown';
+      out.push({ ...row, action: `error:${reason}`, error: message });
+      errors.push({ runId: row.runId, message });
+    }
+  }
+  return { rows: out, errors };
+}
+
+function formatRows(rows) {
+  const lines = [];
+  for (const row of rows) {
+    const tag = row.action.startsWith('skip:')
+      ? `SKIP (${row.action.slice('skip:'.length)})`
+      : row.action.startsWith('error:')
+        ? `ERROR (${row.action.slice('error:'.length)})`
+        : row.deletedAt
+          ? 'DELETED'
+          : 'DELETE';
+    lines.push(`  ${tag.padEnd(22)} ${row.runId.padEnd(38)} age=${row.ageDays.toFixed(2)}d size=${row.size}B`);
+  }
+  return lines.join('\n');
+}
+
+function emitGcLog(rows, errors, { dryRun, maxAgeDays, inProgressIds, outputPath }) {
+  const summary = {
+    dryRun,
+    maxAgeDays,
+    inProgressIds,
+    deleted: rows.filter((r) => r.deletedAt).length,
+    skipped: rows.filter((r) => r.action.startsWith('skip:')).length,
+    errors: rows.filter((r) => r.action.startsWith('error:')).length,
+    rows,
+  };
+  if (outputPath) {
+    try {
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, JSON.stringify(summary, null, 2));
+    } catch {
+      // best-effort: the console output is the source of truth
+    }
+  }
+  return summary;
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  const root = args.root ? resolve(args.root) : undefined;
+  const cwd = process.cwd();
+  const nowMs = Date.now();
+  const inProgress = inProgressFeatureIds(cwd);
+  const runs = listRuns({ runRoot: root });
+  const plan = planCandidates({ runs, nowMs, maxAgeDays: args.maxAgeDays, inProgress: inProgress.inProgress });
+  const { rows } = executePlan(plan, { dryRun: args.dryRun, nowMs });
+  const gcLogPath = resolve(cwd, '.bizar', 'runs', 'gc.json');
+  const summary = emitGcLog(rows, [], { dryRun: args.dryRun, maxAgeDays: args.maxAgeDays, inProgressIds: inProgress.ids, outputPath: gcLogPath });
+
+  process.stdout.write(
+    [
+      `▶ workflow-gc ${args.dryRun ? '(dry-run)' : ''}`,
+      `  root:           ${root || resolve(cwd, '.bizar', 'runs')}`,
+      `  max-age-days:   ${args.maxAgeDays}`,
+      `  in-progress:    ${inProgress.inProgress ? `yes [${inProgress.ids.join(', ')}]` : 'no'}`,
+      `  candidates:     ${rows.length}`,
+      `  deleted:        ${summary.deleted}`,
+      `  skipped:        ${summary.skipped}`,
+      `  errors:         ${summary.errors}`,
+      '',
+      formatRows(rows),
+      '',
+    ].join('\n'),
+  );
+
+  if (summary.errors > 0) {
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+main().catch((err) => {
+  process.stderr.write(`workflow-gc failed: ${err && err.message ? err.message : err}\n`);
+  process.exit(1);
+});

package/config/workflows/bizar-debug.js

@@ -1,4 +1,5 @@
-import { dispatchAgent } from './lib/dispatch.js'
+import { randomUUID } from 'node:crypto'
+import { dispatchAgent, writeArtifact, barrierRef } from './lib/dispatch.js'
 
 export const meta = {
   name: 'bizar-debug',
@@ -21,6 +22,10 @@ const BUG_ID = typeof args === 'string'
       ? args.topic
       : JSON.stringify(args || {})
 
+// Phase B (v10.21.0) artifact-on-disk barriers: one runId per workflow
+// invocation. Used by every writeArtifact() + barrierRef() in this script.
+const RUN_ID = randomUUID()
+
 const HYPOTHESIS = {
   type: 'object',
   required: ['cause', 'experiment', 'predictedOutcome'],
@@ -43,11 +48,15 @@ const iterations = []
 phase('Hypothesis')
 const initial = await dispatchAgent(agent, 'rca-hypothesis', `Root-cause bug ${BUG_ID} with the cheapest discriminating experiment. Return {cause, experiment, predictedOutcome}. Do not propose a fix yet.`, { role: 'research-analyst', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'hypothesis:initial', phase: 'Hypothesis', schema: HYPOTHESIS })
 iterations.push(initial)
+// Phase B: persist initial hypothesis artifact.
+writeArtifact({ runId: RUN_ID, phase: 'Hypothesis', label: 'hypothesis:initial', payload: initial, summary: initial?.cause ? initial.cause.slice(0, 200) : 'initial hypothesis', role: 'research-analyst' })
 
 let accepted = null
 for (let i = 0; i < MAX_ITERATIONS; i++) {
   phase('AdversarialVerify')
-  const verdict = await dispatchAgent(agent, 'rca-verifier', `Refute the RCA hypothesis for bug ${BUG_ID}. Inspect the predicted experiment and reject it if it is speculative, pre-existing, unreachable, or already covered by an existing test.\nHypothesis: ${JSON.stringify(iterations[iterations.length - 1])}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: `verify:${i + 1}`, phase: 'AdversarialVerify', schema: VERDICT })
+  const prior = iterations[iterations.length - 1];
+  const priorLabel = i === 0 ? 'hypothesis:initial' : `refine:${i}`;
+  const verdict = await dispatchAgent(agent, 'rca-verifier', `Refute the RCA hypothesis for bug ${BUG_ID}. Inspect the predicted experiment and reject it if it is speculative, pre-existing, unreachable, or already covered by an existing test.\n${barrierRef({ runId: RUN_ID, phase: 'Hypothesis', label: priorLabel, summary: prior?.cause ? prior.cause.slice(0, 200) : `hypothesis iter ${i + 1}` }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: `verify:${i + 1}`, phase: 'AdversarialVerify', schema: VERDICT })
   if (verdict && verdict.confirmed) {
     accepted = { iteration: i + 1, hypothesis: iterations[iterations.length - 1], verdict }
     break
@@ -57,8 +66,10 @@ for (let i = 0; i < MAX_ITERATIONS; i++) {
     break
   }
   phase('Loop')
-  const refined = await dispatchAgent(agent, 'rca-refiner', `The previous RCA hypothesis for bug ${BUG_ID} was not confirmed. Produce a refined hypothesis with a new cheapest discriminating experiment.\nPrior: ${JSON.stringify(iterations[iterations.length - 1])}\nRejection: ${JSON.stringify(verdict)}`, { role: 'research-analyst', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: `refine:${i + 1}`, phase: 'Loop', schema: HYPOTHESIS })
+  const refined = await dispatchAgent(agent, 'rca-refiner', `The previous RCA hypothesis for bug ${BUG_ID} was not confirmed. Produce a refined hypothesis with a new cheapest discriminating experiment.\n${barrierRef({ runId: RUN_ID, phase: 'Hypothesis', label: priorLabel, summary: prior?.cause ? prior.cause.slice(0, 200) : `prior iter ${i + 1}` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'AdversarialVerify', label: `verify:${i + 1}`, summary: verdict?.reason ? verdict.reason.slice(0, 200) : 'no confirmation' }).promptBlock}`, { role: 'research-analyst', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: `refine:${i + 1}`, phase: 'Loop', schema: HYPOTHESIS })
   iterations.push(refined)
+  // Phase B: persist refined hypothesis artifact.
+  writeArtifact({ runId: RUN_ID, phase: 'Hypothesis', label: `refine:${i + 1}`, payload: refined, summary: refined?.cause ? refined.cause.slice(0, 200) : `refined iter ${i + 1}`, role: 'research-analyst' });
 }
 
 if (!accepted) {
@@ -71,10 +82,11 @@ if (!accepted) {
 }
 
 phase('Fix')
-const fix = await dispatchAgent(agent, 'fix-author', `Produce the smallest fix + regression test for bug ${BUG_ID} based on the accepted hypothesis. Do not commit, push, publish, or deploy.\nAccepted hypothesis: ${JSON.stringify(accepted.hypothesis)}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'fix', phase: 'Fix' })
+const fix = await dispatchAgent(agent, 'fix-author', `Produce the smallest fix + regression test for bug ${BUG_ID} based on the accepted hypothesis. Do not commit, push, publish, or deploy.\n${barrierRef({ runId: RUN_ID, phase: 'Hypothesis', label: 'hypothesis:initial', summary: accepted.hypothesis?.cause ? accepted.hypothesis.cause.slice(0, 200) : 'accepted hypothesis' }).promptBlock}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'fix', phase: 'Fix' })
+writeArtifact({ runId: RUN_ID, phase: 'Fix', label: 'fix', payload: fix, summary: typeof fix === 'string' ? fix.slice(0, 200) : 'fix proposed', role: 'implementer' })
 
 phase('Verify')
-const verify = await dispatchAgent(agent, 'fix-verifier', `Re-check the proposed fix for bug ${BUG_ID} against the regression test and adjacent paths. Reject the fix if it is unbounded, out of scope, or already covered.\nFix: ${String(fix)}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'fix-verify', phase: 'Verify' })
+const verify = await dispatchAgent(agent, 'fix-verifier', `Re-check the proposed fix for bug ${BUG_ID} against the regression test and adjacent paths. Reject the fix if it is unbounded, out of scope, or already covered.\n${barrierRef({ runId: RUN_ID, phase: 'Fix', label: 'fix', summary: typeof fix === 'string' ? fix.slice(0, 200) : 'fix artifact' }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'fix-verify', phase: 'Verify' })
 
 return {
   status: 'dry',

package/config/workflows/bizar-implement.js

@@ -1,4 +1,5 @@
-import { dispatchAgent } from './lib/dispatch.js'
+import { randomUUID } from 'node:crypto'
+import { dispatchAgent, writeArtifact, barrierRef } from './lib/dispatch.js'
 
 export const meta = {
   name: 'bizar-implement',
@@ -20,6 +21,10 @@ const TOPIC = typeof args === 'string'
     : JSON.stringify(args || {})
 const SCOPE = (args && Array.isArray(args.scope)) ? args.scope : []
 
+// Phase B (v10.21.0) artifact-on-disk barriers: one runId per workflow
+// invocation. Used by every writeArtifact() + barrierRef() in this script.
+const RUN_ID = randomUUID()
+
 const LANES = {
   type: 'object',
   required: ['lanes'],
@@ -40,10 +45,13 @@ const LANES = {
 }
 
 phase('Scope')
-const scoped = await dispatchAgent(agent, 'scope-extractor', `Extract 2-6 disjoint edit lanes for: ${TOPIC}\nProvided scope: ${JSON.stringify(SCOPE)}\nEach lane owns a non-overlapping file scope. Shared root/config/lock files must have one owner. Return lanes with name/scope/task.`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'scope-extract', phase: 'Scope', schema: LANES })
+const scoped = await dispatchAgent(agent, 'scope-extractor', `Extract 2-6 disjoint edit lanes for: ${TOPIC}\nProvided scope: ${SCOPE.length ? SCOPE.join(', ') : '(none supplied)'}\nEach lane owns a non-overlapping file scope. Shared root/config/lock files must have one owner. Return lanes with name/scope/task.`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'scope-extract', phase: 'Scope', schema: LANES })
 if (!scoped || !Array.isArray(scoped.lanes) || scoped.lanes.length === 0) {
   return { status: 'blocked', reason: 'Scope agent produced no lanes.' }
 }
+// Phase B: persist the scope artifact for the next barrier agent.
+const scopeSummary = `scope lanes: ${scoped.lanes.map((l) => l.name).join(', ')}`
+writeArtifact({ runId: RUN_ID, phase: 'Scope', label: 'barrier', payload: scoped, summary: scopeSummary, role: 'implementer' })
 const lanes = scoped.lanes.slice(0, 6)
 if (scoped.lanes.length > lanes.length) {
   log(`Bounded implementation to 6 of ${scoped.lanes.length} lanes.`)
@@ -54,22 +62,30 @@ const implementations = (await parallel(
   lanes.map((lane, index) => () => dispatchAgent(
     agent,
     `lane-implementer-${index + 1}`,
-    `Implement this owned lane for the topic "${TOPIC}".\nLane: ${JSON.stringify(lane)}\nDo not edit outside the listed scope. Do not revert sibling work. Add regression tests and run the smallest relevant checks. Return changed files, commands, exact results, and blockers. Do not commit, push, publish, or deploy.`,
+    `Implement this owned lane for the topic "${TOPIC}".\n${barrierRef({ runId: RUN_ID, phase: 'Scope', label: 'barrier', summary: `lane ${lane.name}: ${lane.task.slice(0, 120)}` }).promptBlock}\nDo not edit outside the listed scope. Do not revert sibling work. Add regression tests and run the smallest relevant checks. Return changed files, commands, exact results, and blockers. Do not commit, push, publish, or deploy.`,
     { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: `implement:${index + 1}:${lane.name}`, phase: 'Implement', isolation: 'worktree' },
   )),
 )).filter(Boolean)
 if (implementations.length === 0) {
   return { status: 'blocked', reason: 'No implementation lane completed successfully.', scope: scoped }
 }
+// Phase B: persist each implementation artifact.
+for (let i = 0; i < implementations.length; i++) {
+  const lane = lanes[i];
+  const label = `implement:${i + 1}:${lane.name}`;
+  const summary = `lane ${lane.name} files: ${(implementations[i]?.files || []).slice(0, 5).join(', ')}`;
+  writeArtifact({ runId: RUN_ID, phase: 'Implement', label, payload: implementations[i], summary, role: 'implementer' });
+}
 
 phase('Barrier')
-const merge = await dispatchAgent(agent, 'barrier-merger', `Reconcile the lane outputs for topic "${TOPIC}" into one MERGE plan. Identify conflicts between worktrees, exact integration order, shared-file ownership, and any human approvals required.\nLanes: ${JSON.stringify(lanes)}\nImplementations: ${JSON.stringify(implementations)}`, { role: 'implementer', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'barrier-merge', phase: 'Barrier' })
+const merge = await dispatchAgent(agent, 'barrier-merger', `Reconcile the lane outputs for topic "${TOPIC}" into one MERGE plan. Identify conflicts between worktrees, exact integration order, shared-file ownership, and any human approvals required.\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: 'implement:summary', summary: `${implementations.length} lanes complete across ${lanes.length} planned` }).promptBlock}`, { role: 'implementer', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'barrier-merge', phase: 'Barrier' })
+writeArtifact({ runId: RUN_ID, phase: 'Barrier', label: 'barrier', payload: merge, summary: typeof merge === 'string' ? merge.slice(0, 200) : `barrier merge complete`, role: 'implementer' })
 
 phase('Verify')
-const verify = await dispatchAgent(agent, 'barrier-verifier', `Re-check this MERGE plan against the original scope for topic "${TOPIC}". Reject it if any lane output is missing, any conflict is unresolved, or any test gate is unbounded. Return the verified plan plus the exact gating tests.\nScope: ${JSON.stringify(SCOPE)}\nMerge: ${String(merge)}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'barrier-verify', phase: 'Verify' })
+const verify = await dispatchAgent(agent, 'barrier-verifier', `Re-check this MERGE plan against the original scope for topic "${TOPIC}". Reject it if any lane output is missing, any conflict is unresolved, or any test gate is unbounded. Return the verified plan plus the exact gating tests.\n${barrierRef({ runId: RUN_ID, phase: 'Barrier', label: 'barrier', summary: `verify against scope: ${SCOPE.length} scope items` }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'barrier-verify', phase: 'Verify' })
 
 phase('Synthesis')
-const synthesis = await dispatchAgent(agent, 'integration-reporter', `Produce the final integration report for topic "${TOPIC}". State exact integration order, remaining gates, evidence commands to run, and any required human approvals. Do not claim success without fresh command evidence.\nMerge: ${String(merge)}\nVerify: ${String(verify)}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'integration-report', phase: 'Synthesis' })
+const synthesis = await dispatchAgent(agent, 'integration-reporter', `Produce the final integration report for topic "${TOPIC}". State exact integration order, remaining gates, evidence commands to run, and any required human approvals. Do not claim success without fresh command evidence.\n${barrierRef({ runId: RUN_ID, phase: 'Barrier', label: 'barrier', summary: `merge plan: ${typeof merge === 'string' ? merge.slice(0, 120) : 'complex'}` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Verify', label: 'barrier-verify', summary: typeof verify === 'string' ? verify.slice(0, 120) : 'verified' }).promptBlock}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'integration-report', phase: 'Synthesis' })
 
 return {
   status: 'ready-for-integration',