@polderlabs/bizar 10.20.1 → 10.21.0

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',

package/config/workflows/bizar-research.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-research',
@@ -19,6 +20,11 @@ const TOPIC = 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
+// so the on-disk store + the 3-line barrier block stay paired.
+const RUN_ID = randomUUID()
+
 const BRIEF = {
   type: 'object',
   required: ['summary', 'files', 'risks', 'verification'],
@@ -59,14 +65,22 @@ const research = (await parallel([
 
 if (research.length === 0) return { status: 'blocked', reason: 'No research agent completed successfully.' }
 
+// Phase B: persist the research artifact for the next barrier agent.
+const researchSummary = `research lanes: ${research.map((r) => (r && r.summary) ? r.summary.slice(0, 80) : '<lane>').join(' | ')}`
+writeArtifact({ runId: RUN_ID, phase: 'Research', label: 'barrier', payload: research, summary: researchSummary, role: 'research-analyst' })
+
 phase('Plan')
-const plan = await dispatchAgent(agent, 'plan-author', `Design one reversible implementation for: ${TOPIC}\nResearch:\n${JSON.stringify(research)}\nReturn disjoint edit lanes. Shared root/config/lock files must have one owner. Include bounded tests and stop conditions.`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'plan', phase: 'Plan', schema: PLAN })
+const plan = await dispatchAgent(agent, 'plan-author', `Design one reversible implementation for: ${TOPIC}\n${barrierRef({ runId: RUN_ID, phase: 'Research', label: 'barrier', summary: researchSummary }).promptBlock}\nReturn disjoint edit lanes. Shared root/config/lock files must have one owner. Include bounded tests and stop conditions.`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'plan', phase: 'Plan', schema: PLAN })
 if (!plan || !Array.isArray(plan.lanes) || plan.lanes.length === 0) {
   return { status: 'blocked', reason: 'Planning produced no implementation lanes.', research }
 }
 
+// Phase B: persist the plan artifact for the next barrier agent.
+const planSummary = `plan lanes: ${plan.lanes.map((l) => l.name).join(', ')}`
+writeArtifact({ runId: RUN_ID, phase: 'Plan', label: 'barrier', payload: plan, summary: planSummary, role: 'architect' })
+
 phase('Audit')
-const audit = await dispatchAgent(agent, 'plan-auditor', `Adversarially review this plan for correctness, security, conflicting file ownership, missing regression tests, and unbounded retry loops. Return a corrected plan, not commentary. Topic: ${TOPIC}\nPlan: ${JSON.stringify(plan)}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture', 'security'], label: 'plan-audit', phase: 'Audit', schema: PLAN })
+const audit = await dispatchAgent(agent, 'plan-auditor', `Adversarially review this plan for correctness, security, conflicting file ownership, missing regression tests, and unbounded retry loops. Return a corrected plan, not commentary. Topic: ${TOPIC}\n${barrierRef({ runId: RUN_ID, phase: 'Plan', label: 'barrier', summary: planSummary }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture', 'security'], label: 'plan-audit', phase: 'Audit', schema: PLAN })
 const approved = audit || plan
 
 phase('Implement')
@@ -78,7 +92,7 @@ const implementation = 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: 'Plan', 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' },
   )),
 )
@@ -87,16 +101,29 @@ if (completed.length === 0) {
   return { status: 'blocked', reason: 'No implementation lane completed successfully.', plan: approved }
 }
 
+// Phase B: persist each lane's artifact for the next barrier agent.
+for (let i = 0; i < completed.length; i++) {
+  const lane = lanes[i];
+  const label = `implement:${i + 1}:${lane.name}`;
+  const summary = `lane ${lane.name} files: ${(completed[i]?.files || []).slice(0, 5).join(', ')}`;
+  writeArtifact({ runId: RUN_ID, phase: 'Implement', label, payload: completed[i], summary, role: 'implementer' });
+}
+
 phase('Verify')
 const reviews = await pipeline(
   completed,
   (result, _original, index) => dispatchAgent(
     agent,
     `reviewer-${index + 1}`,
-    `Try to refute this implementation result for topic "${TOPIC}". Check correctness, security, scope, test evidence, and integration assumptions. Return only verified findings and required checks.\nResult: ${String(result)}`,
+    `Try to refute this implementation result for topic "${TOPIC}". Check correctness, security, scope, test evidence, and integration assumptions. Return only verified findings and required checks.\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: `implement:${index + 1}:${lanes[index]?.name || ''}`, summary: `review of lane ${lanes[index]?.name || index + 1}` }).promptBlock}`,
     { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: `review:${index + 1}`, phase: 'Verify' },
   ),
 )
-const final = await dispatchAgent(agent, 'final-verifier', `Synthesize a bounded integration and verification report for topic "${TOPIC}". Do not claim success without fresh command evidence. Identify conflicts between worktrees, exact integration order, remaining gates, and any required human approvals.\nPlan: ${JSON.stringify(approved)}\nImplementations: ${JSON.stringify(completed)}\nReviews: ${JSON.stringify(reviews.filter(Boolean))}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'final-verification', phase: 'Verify' })
+// Phase B: persist review artifacts.
+const verifiedReviews = reviews.filter(Boolean);
+for (let i = 0; i < verifiedReviews.length; i++) {
+  writeArtifact({ runId: RUN_ID, phase: 'Verify', label: `review:${i + 1}`, payload: verifiedReviews[i], summary: typeof verifiedReviews[i] === 'string' ? verifiedReviews[i].slice(0, 200) : `review ${i + 1}`, role: 'adversarial' });
+}
+const final = await dispatchAgent(agent, 'final-verifier', `Synthesize a bounded integration and verification report for topic "${TOPIC}". Do not claim success without fresh command evidence. Identify conflicts between worktrees, exact integration order, remaining gates, and any required human approvals.\n${barrierRef({ runId: RUN_ID, phase: 'Plan', label: 'barrier', summary: `approved plan with ${approved.lanes.length} lanes` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: 'implement:summary', summary: `${completed.length} lanes complete` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Verify', label: 'review:summary', summary: `${verifiedReviews.length} reviews complete` }).promptBlock}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'final-verification', phase: 'Verify' })
 
 return { status: 'ready-for-integration', topic: TOPIC, research, plan: approved, implementation: completed, reviews: reviews.filter(Boolean), final }

package/config/workflows/lib/dispatch.js

@@ -28,7 +28,7 @@
  */
 
 import { randomUUID, createHash } from 'node:crypto';
-import { existsSync, readFileSync, appendFileSync, mkdirSync, writeFileSync, renameSync, openSync, closeSync, fsyncSync, constants as fsConstants } from 'node:fs';
+import { existsSync, readFileSync, appendFileSync, mkdirSync, writeFileSync, renameSync, openSync, closeSync, fsyncSync, rmSync, readdirSync, statSync, constants as fsConstants } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 
@@ -857,3 +857,428 @@ export async function dispatchAgent(agentFn, agentName, prompt, opts = {}, conte
 export async function dispatchAgentDryRun(agentName, prompt, opts = {}) {
   return dispatchAgent(undefined, agentName, prompt, { ...opts, dryRun: true });
 }
+
+/* ────────────────────────────────────────────────────────────────────────── */
+/*              Phase B (v10.21.0) artifact-on-disk barrier store             */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+/**
+ * WorkflowStateError — fail-soft error class used by the artifact store.
+ * Duplicated as a 3-line class to avoid a `cli/` ↔ `config/workflows/`
+ * import cycle. Mirrors `cli/core/workflow-state.mjs:62-66`.
+ */
+export class WorkflowStateError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.name = 'WorkflowStateError';
+    this.code = code;
+    if (details !== undefined) this.details = details;
+  }
+}
+
+/**
+ * Schema version for the artifact store. Bump on any breaking change to
+ * `manifest.json` or the per-phase payload envelope.
+ */
+export const ARTIFACT_SCHEMA_VERSION = 1;
+
+/**
+ * Maximum bytes for a barrier reference summary (the `summary:` field
+ * passed by the workflow script — the human-readable one-liner that
+ * replaces the inline JSON in the next agent's prompt). Default 200 chars
+ * per Phase B plan §4.1. The 3-line barrier block itself is bounded by
+ * `MAX_BARRIER_BYTES = 3072` (B.2 budget).
+ */
+export const MAX_SUMMARY_BYTES = 200;
+export const MAX_BARRIER_BYTES = 3072;
+
+/**
+ * Reduce any string to a kebab-case slug, capped at 64 chars. Used to
+ * derive `phase-slug` and `label-slug` from runtime data
+ * (`meta.phases[i].title` + the `label:` field passed to `dispatchAgent`)
+ * — no hardcoded phase or workflow lists.
+ */
+export function slugify(input, maxLen = 64) {
+  if (typeof input !== 'string') return 'unknown';
+  const slug = input
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  if (!slug) return 'unknown';
+  return slug.length > maxLen ? slug.slice(0, maxLen).replace(/-+$/g, '') : slug;
+}
+
+/**
+ * Resolve the artifact root directory for a run. Defaults to
+ * `<cwd>/.bizar/runs` but can be overridden by `BIZAR_RUNS_DIR` for
+ * tests and for sessions where `.bizar/` lives elsewhere.
+ */
+export function resolveRunRoot({ cwd, env } = {}) {
+  const root = cwd || process.cwd();
+  const override = (env || process.env).BIZAR_RUNS_DIR;
+  if (override && typeof override === 'string' && override.trim()) {
+    return resolve(override);
+  }
+  return join(root, '.bizar', 'runs');
+}
+
+/**
+ * Resolve the directory for a single run-id.
+ */
+function runDirFor(runRoot, runId) {
+  return join(runRoot, runId);
+}
+
+/**
+ * Manifest file co-located with artifacts in `.bizar/runs/<run-id>/`.
+ * Schema: `{ schemaVersion, runId, createdAt, updatedAt, phases: [...] }`
+ * where each entry is `{ phase, label, artifactPath, summaryHash, stale }`.
+ */
+function manifestPathFor(runDir) {
+  return join(runDir, 'manifest.json');
+}
+
+/**
+ * Load a manifest if present. Returns `null` when missing or corrupt.
+ */
+function readManifest(runDir) {
+  const p = manifestPathFor(runDir);
+  if (!existsSync(p)) return null;
+  try {
+    const raw = readFileSync(p, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist the manifest atomically (tmp + rename). Best-effort: a manifest
+ * write failure does NOT abort the artifact write — the next read
+ * reconciles via the directory listing.
+ */
+function writeManifest(runDir, manifest) {
+  const p = manifestPathFor(runDir);
+  const tmp = `${p}.tmp-${randomUUID()}`;
+  writeFileSync(tmp, JSON.stringify(manifest, null, 2));
+  try {
+    fsyncSync(openSync(tmp, 'r+'));
+  } catch {
+    // fsync is best-effort; tolerate filesystems that don't support it.
+  }
+  renameSync(tmp, p);
+}
+
+/**
+ * Compute a stable summary hash. The summary is the human-readable
+ * one-liner the workflow script passes; the hash lets a future audit
+ * prove the summary was not retroactively edited.
+ */
+function summaryHashHex(summary) {
+  return createHash('sha256').update(String(summary ?? '')).digest('hex').slice(0, 16);
+}
+
+/**
+ * Write a phase artifact atomically (tmp file → `rename(2)`). Atomic so
+ * a mid-write crash never leaves a half-written artifact on disk; the
+ * GC tool and the read site can both rely on "every file in the dir is
+ * either complete or absent."
+ *
+ * Naming is data-driven: `<phase-slug>__<label-slug>.json` where slugs
+ * derive from runtime `meta.phases[i].title` + `label:` field via
+ * `slugify()`. No hardcoded phase or workflow lists.
+ *
+ * @param {object} args
+ * @param {string} args.runId      - run identifier (typically `randomUUID()`)
+ * @param {string} args.phase      - phase title (e.g. "Research", "Plan")
+ * @param {string} args.label      - dispatch label (e.g. "plan", "implement:1:foo")
+ * @param {*}      args.payload    - serializable artifact body
+ * @param {string} [args.summary]  - human-readable one-liner (≤200 chars)
+ * @param {string} [args.agent]    - agent name (e.g. "plan-author")
+ * @param {string} [args.role]     - role name from dispatch opts
+ * @param {string} [args.runRoot]  - override artifact root (test only)
+ * @returns {{ runDir: string, artifactPath: string, slug: string, manifestPath: string }}
+ */
+export function writeArtifact(args) {
+  if (!args || typeof args !== 'object') {
+    throw new WorkflowStateError('ARTIFACT_ARGS_REQUIRED', 'writeArtifact requires an args object');
+  }
+  const { runId, phase, label, payload, summary, agent, role } = args;
+  if (!runId || typeof runId !== 'string') {
+    throw new WorkflowStateError('RUN_ID_REQUIRED', 'writeArtifact requires a non-empty runId');
+  }
+  if (!phase || typeof phase !== 'string') {
+    throw new WorkflowStateError('PHASE_REQUIRED', 'writeArtifact requires a non-empty phase');
+  }
+  if (!label || typeof label !== 'string') {
+    throw new WorkflowStateError('LABEL_REQUIRED', 'writeArtifact requires a non-empty label');
+  }
+  if (payload === undefined) {
+    throw new WorkflowStateError('PAYLOAD_REQUIRED', 'writeArtifact requires a payload');
+  }
+
+  const runRoot = args.runRoot || resolveRunRoot();
+  const runDir = runDirFor(runRoot, runId);
+  mkdirSync(runDir, { recursive: true });
+
+  const phaseSlug = slugify(phase);
+  const labelSlug = slugify(label);
+  const slug = `${phaseSlug}__${labelSlug}`;
+  const artifactPath = join(runDir, `${slug}.json`);
+
+  const now = new Date().toISOString();
+  const finalSummary = (() => {
+    if (typeof summary === 'string' && summary.length > 0) {
+      return summary.length > MAX_SUMMARY_BYTES ? summary.slice(0, MAX_SUMMARY_BYTES) : summary;
+    }
+    // Safe default: first 200 chars of canonical payload. Deterministic
+    // so re-running the same upstream agent produces the same summary
+    // and the manifest hash is stable.
+    const text = JSON.stringify(payload) ?? '';
+    return text.length > MAX_SUMMARY_BYTES ? text.slice(0, MAX_SUMMARY_BYTES) : text;
+  })();
+
+  const envelope = {
+    schemaVersion: ARTIFACT_SCHEMA_VERSION,
+    runId,
+    phase,
+    label,
+    agent: typeof agent === 'string' ? agent : undefined,
+    role: typeof role === 'string' ? role : undefined,
+    wroteAt: now,
+    summary: finalSummary,
+    summaryHash: summaryHashHex(finalSummary),
+    payload,
+  };
+
+  // Atomic write: tmp file then rename. fsync before rename so the
+  // file's contents hit disk before the directory entry does. If the
+  // process dies between writeFileSync and renameSync, the tmp file is
+  // orphaned and ignored by readArtifact (which only sees complete files
+  // via the directory listing + manifest).
+  const tmpPath = `${artifactPath}.tmp-${randomUUID()}`;
+  writeFileSync(tmpPath, JSON.stringify(envelope, null, 2));
+  try {
+    fsyncSync(openSync(tmpPath, 'r+'));
+  } catch {
+    // best-effort
+  }
+  renameSync(tmpPath, artifactPath);
+
+  // Manifest update — append/replace the entry for this (phase, label).
+  // Best-effort: if the manifest write fails the artifact is still on
+  // disk and recoverable via readArtifact (which reads the file directly).
+  const prev = readManifest(runDir) || {
+    schemaVersion: ARTIFACT_SCHEMA_VERSION,
+    runId,
+    createdAt: now,
+    updatedAt: now,
+    phases: [],
+  };
+  const entry = {
+    phase,
+    label,
+    artifactPath: `${slug}.json`,
+    summaryHash: envelope.summaryHash,
+    wroteAt: now,
+    stale: false,
+  };
+  const phases = Array.isArray(prev.phases) ? prev.phases.slice() : [];
+  const idx = phases.findIndex((p) => p && p.phase === phase && p.label === label);
+  if (idx >= 0) phases[idx] = entry;
+  else phases.push(entry);
+  const manifest = {
+    schemaVersion: ARTIFACT_SCHEMA_VERSION,
+    runId,
+    createdAt: prev.createdAt || now,
+    updatedAt: now,
+    phases,
+  };
+  try {
+    writeManifest(runDir, manifest);
+  } catch {
+    // Manifest write is best-effort; the artifact itself is durable.
+  }
+
+  return { runDir, artifactPath, slug, manifestPath: manifestPathFor(runDir) };
+}
+
+/**
+ * Read a phase artifact by (runId, phase, label). Returns
+ * `{ payload, summary, manifest, stale, missing }`.
+ *
+ * Fail-soft: a missing or stale artifact returns `{ missing: true }`
+ * or `{ stale: true, ... }`. The reader decides whether to re-render
+ * the upstream phase. This is the Q4 audit recommendation.
+ *
+ * @param {object} args
+ * @param {string} args.runId
+ * @param {string} args.phase
+ * @param {string} args.label
+ * @param {string} [args.runRoot]
+ */
+export function readArtifact(args) {
+  const { runId, phase, label } = args || {};
+  if (!runId || !phase || !label) {
+    throw new WorkflowStateError('ARTIFACT_KEY_REQUIRED', 'readArtifact requires { runId, phase, label }');
+  }
+  const runRoot = args.runRoot || resolveRunRoot();
+  const runDir = runDirFor(runRoot, runId);
+  if (!existsSync(runDir)) {
+    return { missing: true, payload: null, summary: null, manifest: null, stale: false };
+  }
+  const phaseSlug = slugify(phase);
+  const labelSlug = slugify(label);
+  const artifactPath = join(runDir, `${phaseSlug}__${labelSlug}.json`);
+  if (!existsSync(artifactPath)) {
+    return { missing: true, payload: null, summary: null, manifest: readManifest(runDir), stale: false };
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(readFileSync(artifactPath, 'utf8'));
+  } catch {
+    const manifest = readManifest(runDir);
+    return { stale: true, payload: null, summary: null, manifest, missing: false };
+  }
+  // Stale detection: summary hash mismatch with the manifest entry, or
+  // envelope is missing required fields.
+  const manifest = readManifest(runDir);
+  let stale = false;
+  if (!envelope || typeof envelope !== 'object') stale = true;
+  else if (envelope.summaryHash !== summaryHashHex(envelope.summary)) stale = true;
+  else if (Array.isArray(manifest?.phases)) {
+    const entry = manifest.phases.find((p) => p && p.phase === phase && p.label === label);
+    if (entry && entry.stale === true) stale = true;
+    if (entry && entry.summaryHash && entry.summaryHash !== envelope.summaryHash) stale = true;
+  }
+  return {
+    missing: false,
+    stale,
+    payload: stale ? null : envelope.payload,
+    summary: stale ? null : envelope.summary,
+    wroteAt: envelope.wroteAt,
+    manifest,
+    artifactPath,
+  };
+}
+
+/**
+ * List artifacts for a run. Used by the GC tool (B.3) and by tests that
+ * want to introspect the directory shape.
+ *
+ * @param {object} args
+ * @param {string} args.runId
+ * @param {string} [args.runRoot]
+ * @returns {Array<{ phase: string, label: string, slug: string, path: string, size: number, mtimeMs: number }>}
+ */
+export function listArtifacts(args) {
+  const { runId } = args || {};
+  if (!runId || typeof runId !== 'string') {
+    throw new WorkflowStateError('RUN_ID_REQUIRED', 'listArtifacts requires runId');
+  }
+  const runRoot = args.runRoot || resolveRunRoot();
+  const runDir = runDirFor(runRoot, runId);
+  if (!existsSync(runDir)) return [];
+  const out = [];
+  for (const name of readdirSync(runDir)) {
+    if (!name.endsWith('.json')) continue;
+    if (name === 'manifest.json') continue;
+    if (name.includes('.tmp-')) continue; // orphaned tmp from a crashed write
+    const fullPath = join(runDir, name);
+    let stat;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    const sep = name.indexOf('__');
+    if (sep < 0) continue;
+    const phase = name.slice(0, sep);
+    const label = name.slice(sep + 2, -('.json'.length));
+    out.push({ phase, label, slug: name.slice(0, -'.json'.length), path: fullPath, size: stat.size, mtimeMs: stat.mtimeMs });
+  }
+  return out;
+}
+
+/**
+ * List all runs (subdirectories of `.bizar/runs/`). Used by GC.
+ *
+ * @param {object} [args]
+ * @param {string} [args.runRoot]
+ * @returns {Array<{ runId: string, path: string, mtimeMs: number, size: number }>}
+ */
+export function listRuns(args = {}) {
+  const runRoot = args.runRoot || resolveRunRoot();
+  if (!existsSync(runRoot)) return [];
+  const out = [];
+  for (const name of readdirSync(runRoot)) {
+    const fullPath = join(runRoot, name);
+    let stat;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    let size = 0;
+    for (const inner of readdirSync(fullPath)) {
+      try {
+        size += statSync(join(fullPath, inner)).size;
+      } catch {
+        // best-effort size tally
+      }
+    }
+    out.push({ runId: name, path: fullPath, mtimeMs: stat.mtimeMs, size });
+  }
+  return out;
+}
+
+/**
+ * Build the 3-line barrier reference block (B.2). Replaces the inline
+ * `JSON.stringify(priorOutput)` in the next agent's prompt with a
+ * compact reference that points at the on-disk artifact.
+ *
+ *   prior phase: <phase>
+ *   prior label: <label>
+ *   summary:     <≤200 chars>
+ *   path:        <absolute path to .bizar/runs/<id>/<slug>.json>
+ *
+ * Block is bounded by `MAX_BARRIER_BYTES`; if the script passes a
+ * `summary` larger than the budget, it is truncated and the call is
+ * noted via `truncated: true` in the return value.
+ *
+ * @param {object} args
+ * @param {string} args.runId
+ * @param {string} args.phase
+ * @param {string} args.label
+ * @param {string} [args.summary]
+ * @param {string} [args.runRoot]
+ * @returns {{ promptBlock: string, path: string, truncated: boolean, bytes: number }}
+ */
+export function barrierRef(args) {
+  const { runId, phase, label, summary } = args || {};
+  if (!runId || !phase || !label) {
+    throw new WorkflowStateError('BARRIER_KEY_REQUIRED', 'barrierRef requires { runId, phase, label }');
+  }
+  const runRoot = args.runRoot || resolveRunRoot();
+  const runDir = runDirFor(runRoot, runId);
+  const slug = `${slugify(phase)}__${slugify(label)}`;
+  const path = join(runDir, `${slug}.json`);
+
+  let boundedSummary = typeof summary === 'string' ? summary : '';
+  let truncated = false;
+  if (boundedSummary.length > MAX_SUMMARY_BYTES) {
+    boundedSummary = boundedSummary.slice(0, MAX_SUMMARY_BYTES);
+    truncated = true;
+  }
+  const promptBlock = [
+    `prior phase: ${phase}`,
+    `prior label: ${label}`,
+    `summary:     ${boundedSummary}`,
+    `path:        ${path}`,
+  ].join('\n');
+  return { promptBlock, path, truncated: truncated || promptBlock.length > MAX_BARRIER_BYTES, bytes: Buffer.byteLength(promptBlock, 'utf8') };
+}
+

package/config/workflows/ultracode-research.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: 'ultracode-research',
@@ -12,6 +13,10 @@ export const meta = {
 }
 
 const QUESTION = typeof args === 'string' ? args : args?.question || 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 EVIDENCE = {
   type: 'object',
   required: ['claims', 'gaps'],
@@ -36,9 +41,14 @@ const evidence = (await parallel([
 ])).filter(Boolean)
 if (evidence.length === 0) return { status: 'blocked', reason: 'No research pass completed.' }
 
+// Phase B: persist evidence artifact for the next barrier agent.
+const evidenceSummary = `${evidence.length} evidence passes with ${evidence.reduce((n, e) => n + (Array.isArray(e?.claims) ? e.claims.length : 0), 0)} total claims`
+writeArtifact({ runId: RUN_ID, phase: 'Research', label: 'barrier', payload: evidence, summary: evidenceSummary, role: 'research-analyst' })
+
 phase('Critique')
-const critique = await dispatchAgent(agent, 'completeness-critic', `Challenge these research claims. Identify contradictions, unread sources, outdated assumptions, and claims lacking reproducible evidence.\nQuestion: ${QUESTION}\nEvidence: ${JSON.stringify(evidence)}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'completeness-critic', phase: 'Critique', schema: EVIDENCE })
+const critique = await dispatchAgent(agent, 'completeness-critic', `Challenge these research claims. Identify contradictions, unread sources, outdated assumptions, and claims lacking reproducible evidence.\nQuestion: ${QUESTION}\n${barrierRef({ runId: RUN_ID, phase: 'Research', label: 'barrier', summary: evidenceSummary }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: 'completeness-critic', phase: 'Critique', schema: EVIDENCE })
+writeArtifact({ runId: RUN_ID, phase: 'Critique', label: 'barrier', payload: critique, summary: typeof critique === 'string' ? critique.slice(0, 200) : 'critique complete', role: 'adversarial' })
 
 phase('Synthesize')
-const synthesis = await dispatchAgent(agent, 'synthesis-author', `Produce a concise sourced decision brief for: ${QUESTION}. Separate verified facts, repository-specific implications, recommendation, risks, and unresolved gaps. Do not invent consensus or hide evidence gaps.\nEvidence: ${JSON.stringify(evidence)}\nCritique: ${JSON.stringify(critique)}`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'synthesis', phase: 'Synthesize' })
+const synthesis = await dispatchAgent(agent, 'synthesis-author', `Produce a concise sourced decision brief for: ${QUESTION}. Separate verified facts, repository-specific implications, recommendation, risks, and unresolved gaps. Do not invent consensus or hide evidence gaps.\n${barrierRef({ runId: RUN_ID, phase: 'Research', label: 'barrier', summary: evidenceSummary }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Critique', label: 'barrier', summary: typeof critique === 'string' ? critique.slice(0, 200) : 'critique complete' }).promptBlock}`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'synthesis', phase: 'Synthesize' })
 return { question: QUESTION, evidence, critique, synthesis }

package/config/workflows/ultracode-review.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: 'ultracode-review',
@@ -11,6 +12,10 @@ export const meta = {
 }
 
 const TARGET = typeof args === 'string' ? args : args?.target || 'the current working diff'
+
+// 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 FINDINGS = {
   type: 'object',
   required: ['findings'],
@@ -57,7 +62,7 @@ const reviewed = await pipeline(
   lenses,
   (lens) => dispatchAgent(agent, `reviewer-${lens[0]}`, `Review ${TARGET} through the ${lens[0]} lens. ${lens[1]} Report only actionable defects with a concrete failure scenario; do not praise or speculate.`, { ...lensRole[lens[0]], label: `review:${lens[0]}`, phase: 'Review', schema: FINDINGS }),
   (review, original) => (review?.findings || []).slice(0, 12).map((finding) => ({ ...finding, lens: original[0] })),
-  (findings) => parallel(findings.map((finding, index) => () => dispatchAgent(agent, `finding-verifier-${index + 1}`, `Try to refute this proposed finding. Inspect the exact code path and reject it if it is speculative, pre-existing, unreachable, or already covered.\n${JSON.stringify(finding)}`, { role: 'adversarial', risk: 'high', capabilities: ['reasoning', 'structured-output'], label: `verify:${index + 1}:${finding.file}`, phase: 'Verify', schema: VERDICT }).then((verdict) => ({ finding, verdict })))),
+  (findings) => parallel(findings.map((finding, index) => () => dispatchAgent(agent, `finding-verifier-${index + 1}`, `Try to refute this proposed finding. Inspect the exact code path and reject it if it is speculative, pre-existing, unreachable, or already covered.\n${barrierRef({ runId: RUN_ID, phase: 'Review', label: `review:${finding.lens || 'mixed'}`, summary: `${finding.summary ? finding.summary.slice(0, 200) : `finding in ${finding.file}`}` }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['reasoning', 'structured-output'], label: `verify:${index + 1}:${finding.file}`, phase: 'Verify', schema: VERDICT }).then((verdict) => ({ finding, verdict })))),
 )
 
 const verified = reviewed.flat(2).filter(Boolean).filter((item) => item.verdict?.confirmed).map((item) => ({ ...item.finding, verification: item.verdict.reason }))

package/config/workflows/ultracode.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: 'ultracode',
@@ -13,6 +14,10 @@ export const meta = {
 }
 
 const TASK = typeof args === 'string' ? args : args?.task || 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 BRIEF = {
   type: 'object',
   required: ['summary', 'files', 'risks', 'verification'],
@@ -52,11 +57,19 @@ const research = (await parallel([
 
 if (research.length === 0) return { status: 'blocked', reason: 'No research agent completed successfully.' }
 
+// Phase B: persist research artifact for the next barrier agent.
+const researchSummary = `research lanes: ${research.map((r) => (r && r.summary) ? r.summary.slice(0, 80) : '<lane>').join(' | ')}`
+writeArtifact({ runId: RUN_ID, phase: 'Research', label: 'barrier', payload: research, summary: researchSummary, role: 'research-analyst' })
+
 phase('Design')
-const plan = await dispatchAgent(agent, 'plan-author', `Design one reversible implementation for: ${TASK}\nResearch:\n${JSON.stringify(research)}\nReturn disjoint edit lanes. Shared root/config/lock files must have one owner. Include bounded tests and stop conditions.`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'plan', phase: 'Design', schema: PLAN })
+const plan = await dispatchAgent(agent, 'plan-author', `Design one reversible implementation for: ${TASK}\n${barrierRef({ runId: RUN_ID, phase: 'Research', label: 'barrier', summary: researchSummary }).promptBlock}\nReturn disjoint edit lanes. Shared root/config/lock files must have one owner. Include bounded tests and stop conditions.`, { role: 'architect', risk: 'medium', capabilities: ['structured-output', 'reasoning', 'architecture'], label: 'plan', phase: 'Design', schema: PLAN })
 if (!plan || !Array.isArray(plan.lanes) || plan.lanes.length === 0) return { status: 'blocked', reason: 'Planning produced no implementation lanes.', research }
 
-const audit = await dispatchAgent(agent, 'plan-auditor', `Adversarially review this plan for correctness, security, conflicting file ownership, missing regression tests, and unbounded retry loops. Return a corrected plan, not commentary. Task: ${TASK}\nPlan: ${JSON.stringify(plan)}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture', 'security'], label: 'plan-audit', phase: 'Design', schema: PLAN })
+// Phase B: persist plan artifact for the next barrier agent.
+const planSummary = `plan lanes: ${plan.lanes.map((l) => l.name).join(', ')}`
+writeArtifact({ runId: RUN_ID, phase: 'Design', label: 'barrier', payload: plan, summary: planSummary, role: 'architect' })
+
+const audit = await dispatchAgent(agent, 'plan-auditor', `Adversarially review this plan for correctness, security, conflicting file ownership, missing regression tests, and unbounded retry loops. Return a corrected plan, not commentary. Task: ${TASK}\n${barrierRef({ runId: RUN_ID, phase: 'Design', label: 'barrier', summary: planSummary }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning', 'architecture', 'security'], label: 'plan-audit', phase: 'Design', schema: PLAN })
 const approved = audit || plan
 
 phase('Implement')
@@ -64,16 +77,28 @@ const lanes = approved.lanes.slice(0, 8)
 if (approved.lanes.length > lanes.length) log(`Bounded implementation to 8 of ${approved.lanes.length} lanes; ${approved.lanes.length - lanes.length} lanes were not dispatched.`)
 const implementation = await pipeline(
   lanes,
-  (lane, _original, index) => dispatchAgent(agent, `lane-implementer-${index + 1}`, `Implement this owned lane for the task "${TASK}".\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.`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: `implement:${index + 1}:${lane.name}`, phase: 'Implement', isolation: 'worktree' }),
+  (lane, _original, index) => dispatchAgent(agent, `lane-implementer-${index + 1}`, `Implement this owned lane for the task "${TASK}".\n${barrierRef({ runId: RUN_ID, phase: 'Design', 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' }),
 )
 const completed = implementation.filter(Boolean)
 if (completed.length === 0) return { status: 'blocked', reason: 'No implementation lane completed successfully.', plan: approved }
+// Phase B: persist each implementation artifact.
+for (let i = 0; i < completed.length; i++) {
+  const lane = lanes[i];
+  const label = `implement:${i + 1}:${lane.name}`;
+  const summary = `lane ${lane.name} files: ${(completed[i]?.files || []).slice(0, 5).join(', ')}`;
+  writeArtifact({ runId: RUN_ID, phase: 'Implement', label, payload: completed[i], summary, role: 'implementer' });
+}
 
 phase('Verify')
 const reviews = await pipeline(
   completed,
-  (result, _original, index) => dispatchAgent(agent, `reviewer-${index + 1}`, `Try to refute this implementation result for task "${TASK}". Check correctness, security, scope, test evidence, and integration assumptions. Return only verified findings and required checks.\nResult: ${String(result)}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: `review:${index + 1}`, phase: 'Verify' }),
+  (result, _original, index) => dispatchAgent(agent, `reviewer-${index + 1}`, `Try to refute this implementation result for task "${TASK}". Check correctness, security, scope, test evidence, and integration assumptions. Return only verified findings and required checks.\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: `implement:${index + 1}:${lanes[index]?.name || ''}`, summary: `review of lane ${lanes[index]?.name || index + 1}` }).promptBlock}`, { role: 'adversarial', risk: 'high', capabilities: ['structured-output', 'reasoning'], label: `review:${index + 1}`, phase: 'Verify' }),
 )
-const final = await dispatchAgent(agent, 'final-verifier', `Synthesize a bounded integration and verification report for task "${TASK}". Do not claim success without fresh command evidence. Identify conflicts between worktrees, exact integration order, remaining gates, and any required human approvals.\nPlan: ${JSON.stringify(approved)}\nImplementations: ${JSON.stringify(completed)}\nReviews: ${JSON.stringify(reviews.filter(Boolean))}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'final-verification', phase: 'Verify' })
+// Phase B: persist review artifacts.
+const verifiedReviews = reviews.filter(Boolean);
+for (let i = 0; i < verifiedReviews.length; i++) {
+  writeArtifact({ runId: RUN_ID, phase: 'Verify', label: `review:${i + 1}`, payload: verifiedReviews[i], summary: typeof verifiedReviews[i] === 'string' ? verifiedReviews[i].slice(0, 200) : `review ${i + 1}`, role: 'adversarial' });
+}
+const final = await dispatchAgent(agent, 'final-verifier', `Synthesize a bounded integration and verification report for task "${TASK}". Do not claim success without fresh command evidence. Identify conflicts between worktrees, exact integration order, remaining gates, and any required human approvals.\n${barrierRef({ runId: RUN_ID, phase: 'Design', label: 'barrier', summary: `approved plan with ${approved.lanes.length} lanes` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Implement', label: 'implement:summary', summary: `${completed.length} lanes complete` }).promptBlock}\n${barrierRef({ runId: RUN_ID, phase: 'Verify', label: 'review:summary', summary: `${verifiedReviews.length} reviews complete` }).promptBlock}`, { role: 'implementer', risk: 'medium', capabilities: ['structured-output', 'reasoning'], label: 'final-verification', phase: 'Verify' })
 
 return { status: 'ready-for-integration', task: TASK, research, plan: approved, implementation: completed, reviews: reviews.filter(Boolean), final }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.20.1",
+  "version": "10.21.0",
   "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {
@@ -42,7 +42,9 @@
     "test": "npm run build:sdk && npm run test:sdk && npm run test:node",
     "build": "npm run build:sdk",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "workflow:gc": "node cli/commands/workflow-gc.mjs",
+    "workflow:gc:dry": "node cli/commands/workflow-gc.mjs --dry-run"
   },
   "keywords": [
     "claude-code",