@polderlabs/bizar 6.2.5 → 7.0.0

package/cli/feature-list-bridge.mjs

@@ -0,0 +1,400 @@
+/**
+ * cli/feature-list-bridge.mjs
+ *
+ * F-035 (MetaHarness) — wraps `feature_list.json` with claim semantics.
+ *
+ * Source-of-truth port from
+ *   ruflo/v3/@claude-flow/cli/src/services/claim-service.ts (ClaimService,
+ *   ADR-016) — issues.ts is the CLI surface we mirror.
+ *
+ * Status state machine:
+ *   unclaimed -> claimed
+ *   claimed -> active             (start work)
+ *   active -> paused
+ *   paused -> active
+ *   active -> handoff-pending     (initiated)
+ *   handoff-pending -> claimed    (accepted by recipient)
+ *   active -> blocked             (caller marked a blocker)
+ *   blocked -> active
+ *   {claimed,active,paused,blocked,handoff-pending}
+ *                          -> completed
+ *   {claimed,active,...}   -> unclaimed (release)
+ *
+ * Steal reasons (per spec): overloaded | stale | blocked-timeout | voluntary
+ *
+ * Persistence model: we ADD the following fields on each feature entry —
+ *   claimant      : { type: 'human'|'agent', id, name }
+ *   claimStatus   : ClaimStatus
+ *   claimedAt     : ISO timestamp
+ *   claimHistory  : Array<{ event, claimant?, ts, reason? }>
+ *
+ * We MUST NOT modify the existing `vcr` / `passing` semantics of
+ * feature_list.json — claims are additive fields only.
+ *
+ * File writes are atomic via the standard `writeFileSync` to .tmp +
+ * `renameSync` pattern.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, statSync, copyFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+// ── Constants ────────────────────────────────────────────────────────
+
+export const CLAIM_STATUSES = Object.freeze([
+  'unclaimed',
+  'claimed',
+  'active',
+  'paused',
+  'handoff-pending',
+  'blocked',
+  'completed',
+]);
+
+export const STEAL_REASONS = Object.freeze([
+  'overloaded',
+  'stale',
+  'blocked-timeout',
+  'voluntary',
+]);
+
+// Transitions the bridge will allow without complaint. Anything else
+// emits a typed error.
+const ALLOWED_TRANSITIONS = {
+  unclaimed:          new Set(['claimed']),
+  claimed:            new Set(['active', 'unclaimed', 'completed', 'handoff-pending']),
+  active:             new Set(['paused', 'blocked', 'completed', 'handoff-pending', 'unclaimed']),
+  paused:             new Set(['active', 'unclaimed', 'completed']),
+  'handoff-pending':  new Set(['claimed', 'unclaimed']),
+  blocked:            new Set(['active', 'unclaimed']),
+  completed:          new Set([]),
+};
+
+// ── Errors ───────────────────────────────────────────────────────────
+
+export class ClaimError extends Error {
+  constructor(code, message) {
+    super(message || code);
+    this.name = 'ClaimError';
+    this.code = code;
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function readJsonSafe(file) {
+  try {
+    if (!existsSync(file)) return null;
+    const txt = readFileSync(file, 'utf8');
+    return JSON.parse(txt);
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonAtomic(file, data) {
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.tmp.${randomUUID()}`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+  renameSync(tmp, file);
+}
+
+function appendHistory(feature, event, extra) {
+  const prev = Array.isArray(feature.claimHistory) ? feature.claimHistory : [];
+  feature.claimHistory = [...prev, { event, ts: nowIso(), ...(extra || {}) }];
+}
+
+function setClaim(feature, status, claimant, reason) {
+  feature.claimant = claimant || null;
+  feature.claimStatus = status;
+  if (status === 'claimed' || status === 'active' || status === 'paused' || status === 'handoff-pending' || status === 'blocked') {
+    if (!feature.claimedAt) feature.claimedAt = nowIso();
+  }
+  if (status === 'unclaimed' || status === 'completed') {
+    // Keep claimedAt as historical record.
+  }
+  if (reason) feature.claimReason = reason;
+}
+
+function assertStatus(s) {
+  if (!CLAIM_STATUSES.includes(s)) {
+    throw new ClaimError('UNKNOWN_STATUS', `Unknown claim status: ${s}`);
+  }
+}
+
+function assertReason(r) {
+  if (!STEAL_REASONS.includes(r)) {
+    throw new ClaimError('UNKNOWN_STEAL_REASON', `Unknown steal reason: ${r}`);
+  }
+}
+
+// ── FeatureListBridge ────────────────────────────────────────────────
+
+export class FeatureListBridge {
+  /**
+   * @param {object|string} opts Either a path string or `{ filePath, backup }`.
+   *   - filePath: path to feature_list.json (default: ./feature_list.json)
+   *   - backup  : write a .bak copy before each write (default: true)
+   */
+  constructor(opts = {}) {
+    if (typeof opts === 'string') {
+      this.filePath = resolve(opts);
+    } else {
+      this.filePath = resolve(opts.filePath || 'feature_list.json');
+      this.backup = opts.backup !== false;
+    }
+  }
+
+  /** Load the feature list from disk. Returns the parsed JSON. */
+  load() {
+    const data = readJsonSafe(this.filePath);
+    if (!data) {
+      throw new ClaimError('NO_FILE', `feature_list.json not found at ${this.filePath}`);
+    }
+    if (!Array.isArray(data.features)) {
+      throw new ClaimError('SCHEMA', 'feature_list.json missing top-level features[]');
+    }
+    return data;
+  }
+
+  /** Save + atomic temp-rename. Creates a .bak if `backup=true`. */
+  save(data, { reason = 'update' } = {}) {
+    if (this.backup && existsSync(this.filePath)) {
+      try { copyFileSync(this.filePath, `${this.filePath}.bak`); } catch { /* best-effort */ }
+    }
+    writeJsonAtomic(this.filePath, data);
+    return { ok: true, path: this.filePath, reason };
+  }
+
+  _find(data, featureId) {
+    const idx = data.features.findIndex((f) => f.id === featureId);
+    if (idx === -1) {
+      throw new ClaimError('NOT_FOUND', `Feature ${featureId} not in feature_list.json`);
+    }
+    return idx;
+  }
+
+  _getOrThrow(data, featureId) {
+    return data.features[this._find(data, featureId)];
+  }
+
+  // ── claim ─────────────────────────────────────────────────────────
+
+  /**
+   * @param {string} featureId
+   * @param {{type:'human'|'agent', id:string, name?:string}} claimant
+   * @param {string} reason
+   * @returns {{ ok: true, feature: object }}
+   */
+  claim(featureId, claimant, reason) {
+    if (!claimant || (claimant.type !== 'human' && claimant.type !== 'agent')) {
+      throw new ClaimError('BAD_CLAIMANT', 'claimant must be {type:"human"|"agent", id, name?}');
+    }
+    const data = this.load();
+    const feature = this._getOrThrow(data, featureId);
+    const prev = feature.claimant || null;
+    const prevStatus = feature.claimStatus || 'unclaimed';
+
+    if (prevStatus !== 'unclaimed' && prevStatus !== 'completed') {
+      throw new ClaimError(
+        'ALREADY_CLAIMED',
+        `Feature ${featureId} is ${prevStatus} by ${prev?.name || prev?.id || 'unknown'} — release or steal first.`,
+      );
+    }
+
+    feature.claimant = claimant;
+    feature.claimStatus = 'claimed';
+    feature.claimedAt = nowIso();
+    if (reason) feature.claimReason = reason;
+    appendHistory(feature, 'claim', { claimant, reason });
+
+    this.save(data, { reason: `claim:${featureId}` });
+    return { ok: true, feature, previousClaimant: prev };
+  }
+
+  // ── release ───────────────────────────────────────────────────────
+
+  /**
+   * @param {string} featureId
+   * @param {{id:string}} claimant   expected to match the current claimant
+   * @param {string} reason
+   */
+  release(featureId, claimant, reason) {
+    const data = this.load();
+    const feature = this._getOrThrow(data, featureId);
+    const prevStatus = feature.claimStatus || 'unclaimed';
+    if (prevStatus === 'unclaimed' || prevStatus === 'completed') {
+      throw new ClaimError(
+        'NOT_CLAIMED',
+        `Feature ${featureId} is ${prevStatus}; nothing to release.`,
+      );
+    }
+    if (claimant && feature.claimant && feature.claimant.id !== claimant.id) {
+      throw new ClaimError(
+        'WRONG_CLAIMANT',
+        `Feature ${featureId} is claimed by ${feature.claimant.name || feature.claimant.id}, not ${claimant.name || claimant.id}.`,
+      );
+    }
+    const prev = feature.claimant;
+    feature.claimStatus = 'unclaimed';
+    appendHistory(feature, 'release', { releasedBy: claimant, reason });
+    // Keep claimant for historical record (the entry's `claimHistory`
+    // captures who held it); but flip `claimant` to null so further
+    // list({status: 'claimed'}) filters don't pick it up accidentally.
+    feature.claimant = null;
+
+    this.save(data, { reason: `release:${featureId}` });
+    return { ok: true, feature, previousClaimant: prev };
+  }
+
+  // ── handoff ───────────────────────────────────────────────────────
+
+  /**
+   * Hand off the feature from one claimant to another.
+   * The recipient must be a valid claimant shape.
+   */
+  handoff(featureId, fromClaimant, toClaimant, reason) {
+    if (!toClaimant || (toClaimant.type !== 'human' && toClaimant.type !== 'agent')) {
+      throw new ClaimError('BAD_CLAIMANT', 'toClaimant must be {type:"human"|"agent", id, name?}');
+    }
+    const data = this.load();
+    const feature = this._getOrThrow(data, featureId);
+    const prevStatus = feature.claimStatus || 'unclaimed';
+    if (prevStatus === 'unclaimed' || prevStatus === 'completed') {
+      throw new ClaimError('NOT_CLAIMED', `Feature ${featureId} is ${prevStatus}; cannot handoff.`);
+    }
+    if (fromClaimant && feature.claimant && feature.claimant.id !== fromClaimant.id) {
+      throw new ClaimError(
+        'WRONG_CLAIMANT',
+        `Feature ${featureId} is held by ${feature.claimant.name || feature.claimant.id}, not ${fromClaimant.name || fromClaimant.id}.`,
+      );
+    }
+
+    appendHistory(feature, 'handoff-initiated', { from: feature.claimant, to: toClaimant, reason });
+    feature.handoffTo = toClaimant;
+    feature.claimStatus = 'handoff-pending';
+
+    // Synchronous accept per the simplest semantics — the CLI flag
+    // `bizar claim handoff` accepts immediately. An async workflow
+    // would split this into handoff-initiate + handoff-accept, but
+    // v1 keeps it atomic.
+    feature.claimant = toClaimant;
+    feature.claimStatus = 'claimed';
+    feature.claimedAt = nowIso();
+    appendHistory(feature, 'handoff-accepted', { by: toClaimant, reason });
+    delete feature.handoffTo;
+
+    this.save(data, { reason: `handoff:${featureId}` });
+    return { ok: true, feature };
+  }
+
+  // ── steal ─────────────────────────────────────────────────────────
+
+  /**
+   * Steal a feature from the current claimant. Requires a `stealReason`
+   * (one of STEAL_REASONS). Records the event in `claimHistory`.
+   */
+  steal(featureId, newClaimant, reason) {
+    assertReason(reason);
+    if (!newClaimant || (newClaimant.type !== 'human' && newClaimant.type !== 'agent')) {
+      throw new ClaimError('BAD_CLAIMANT', 'newClaimant must be {type:"human"|"agent", id, name?}');
+    }
+    const data = this.load();
+    const feature = this._getOrThrow(data, featureId);
+    const prevStatus = feature.claimStatus || 'unclaimed';
+    if (prevStatus === 'unclaimed' || prevStatus === 'completed') {
+      throw new ClaimError('NOT_CLAIMED', `Feature ${featureId} is ${prevStatus}; nothing to steal.`);
+    }
+    const prev = feature.claimant;
+    appendHistory(feature, 'steal', { stolenFrom: prev, stolenBy: newClaimant, reason });
+    feature.claimant = newClaimant;
+    feature.claimStatus = 'claimed';
+    feature.claimedAt = nowIso();
+    feature.claimReason = reason;
+
+    this.save(data, { reason: `steal:${featureId}` });
+    return { ok: true, feature, previousClaimant: prev, stealReason: reason };
+  }
+
+  // ── transition ────────────────────────────────────────────────────
+
+  /**
+   * Generic status transition (active / paused / blocked / completed).
+   * Used by the CLI to mark a claim actively-in-progress, paused,
+   * blocked, or completed.
+   */
+  transition(featureId, newStatus, claimant, reason) {
+    assertStatus(newStatus);
+    const data = this.load();
+    const feature = this._getOrThrow(data, featureId);
+    const prevStatus = feature.claimStatus || 'unclaimed';
+    if (newStatus === prevStatus) {
+      return { ok: true, feature, unchanged: true };
+    }
+    const allowed = ALLOWED_TRANSITIONS[prevStatus] || new Set();
+    if (!allowed.has(newStatus)) {
+      throw new ClaimError(
+        'BAD_TRANSITION',
+        `Cannot transition ${featureId}: ${prevStatus} → ${newStatus} not allowed.`,
+      );
+    }
+    if (claimant && feature.claimant && feature.claimant.id !== claimant.id) {
+      throw new ClaimError(
+        'WRONG_CLAIMANT',
+        `Feature ${featureId} is held by ${feature.claimant.name || feature.claimant.id}, not ${claimant.name || claimant.id}.`,
+      );
+    }
+    appendHistory(feature, 'transition', { from: prevStatus, to: newStatus, by: claimant, reason });
+    feature.claimStatus = newStatus;
+
+    this.save(data, { reason: `transition:${featureId}:${newStatus}` });
+    return { ok: true, feature };
+  }
+
+  // ── list ──────────────────────────────────────────────────────────
+
+  /**
+   * List features, optionally filtered by status or claimant.
+   * @param {{status?:string|string[], claimantId?:string}} filters
+   */
+  list(filters = {}) {
+    const data = this.load();
+    let out = data.features.slice();
+    if (filters.status) {
+      const statuses = Array.isArray(filters.status) ? filters.status : [filters.status];
+      out = out.filter((f) => statuses.includes(f.claimStatus || 'unclaimed'));
+    }
+    if (filters.claimantId) {
+      out = out.filter((f) => f.claimant && f.claimant.id === filters.claimantId);
+    }
+    if (filters.claimedByHuman != null) {
+      out = out.filter((f) => Boolean(f.claimant) === Boolean(filters.claimedByHuman) && (!f.claimant || f.claimant.type === 'human'));
+    }
+    if (filters.claimedByAgent != null) {
+      out = out.filter((f) => Boolean(f.claimant) && f.claimant.type === 'agent');
+    }
+    return out;
+  }
+
+  /** Get a single feature with its full claim history. */
+  get(featureId) {
+    const data = this.load();
+    return this._getOrThrow(data, featureId);
+  }
+}
+
+// ── Path helper ──────────────────────────────────────────────────────
+
+import { cwd } from 'node:process';
+
+/** Default path under cwd / feature_list.json. */
+export function defaultFeatureListPath() {
+  if (process.env.BIZAR_FEATURE_LIST && process.env.BIZAR_FEATURE_LIST.trim()) {
+    return resolve(process.env.BIZAR_FEATURE_LIST);
+  }
+  return join(cwd(), 'feature_list.json');
+}

package/cli/install.mjs

@@ -16,7 +16,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 import { showBanner, showPantheon, sectionHeading } from './banner.mjs';
 import { promptComponents, promptInstallMode, promptAgents, promptSkillPacks, promptApiKeys, promptConfirmInstall, promptRestartCline } from './prompts.mjs';
-import { detectCline, detectHeadroom, detectSemble, detectSkillsCli, detectUv, buildSummary, clineAgentsDir, clineConfigDir, repoPath } from './utils.mjs';
+import { detectClaude, detectHeadroom, detectSemble, detectSkillsCli, detectUv, buildSummary, claudeAgentsDir, claudeConfigDir, repoPath } from './utils.mjs';
 import { installAgents, installAgentsMd, installSkill, installClineJson, installBizarFolder, installPluginBizar, installHeadroom, installSemble, installSkillsCli, installCuratedSkills, installRules, installHooks, installCommands, installCommandsBizar, mergeToolsIntoUserConfig } from './copy.mjs';
 
 const AGENT_FILES = [
@@ -27,8 +27,12 @@ const AGENT_FILES = [
 ];
 
 /**
- * Install the Bizar cline plugin from this package's own
- * `plugins/bizar/` directory into `~/.config/cline/plugins/bizar/`.
+ * Install the Bizar MCP server from this package's own `plugins/bizar/`
+ * directory into `~/.claude/plugins/bizar/`.
+ *
+ * v6.3.0 — Bizar is Claude Code-native. The plugin entry-point still
+ * ships at `plugins/bizar/` as a back-compat shim that re-exports the
+ * SDK; the actual MCP server lives in `packages/sdk/src/mcp/bin.ts`.
  *
  * v4.0.0 consolidated everything into one npm package, so the plugin
  * source ships with `@polderlabs/bizar` itself — no separate
@@ -44,8 +48,8 @@ const AGENT_FILES = [
  * workspace-internal package not on the public registry. After copying
  * the plugin files, this function ALSO copies the source's `node_modules/`
  * to the deployed `node_modules/` so Bun can resolve the import when the
- * plugin is loaded from `~/.config/cline/plugins/bizar/`. Without
- * this, the plugin silently fails to load.
+ * plugin is loaded from `~/.claude/plugins/bizar/`. Without this, the
+ * plugin silently fails to load.
  *
  * Pass `{ silent: true }` to suppress the warning prints; the function
  * still returns `true` if the dest is already in the desired state.
@@ -65,7 +69,7 @@ export async function installPluginFromGlobal(opts = {}) {
   // A plain copy would dereference the symlink and silently break the
   // dev workflow. Print a hint unless silent, or honour an explicit
   // --force from the caller.
-  const destDir = join(clineConfigDir(), 'plugins', 'bizar');
+  const destDir = join(claudeConfigDir(), 'plugins', 'bizar');
   let destIsSymlink = false;
   try {
     destIsSymlink = lstatSync(destDir).isSymbolicLink();
@@ -81,7 +85,7 @@ export async function installPluginFromGlobal(opts = {}) {
     }
     console.log(
       chalk.yellow(
-        '  ⚠ ~/.config/cline/plugins/bizar is a dev symlink — skipping copy.',
+        '  ⚠ ~/.claude/plugins/bizar is a dev symlink — skipping copy.',
       ),
     );
     console.log(
@@ -197,11 +201,11 @@ export async function installPluginFromGlobal(opts = {}) {
       }
     }
 
-    // Wire runtime deps (`zod` plus `@cline/sdk`, `@cline/core`,
-    // `@cline/shared`) into the deployed plugin's `node_modules/`.
+    // Wire runtime deps (`zod` plus `@anthropic-ai/claude-agent-sdk`)
+    // into the deployed plugin's `node_modules/`.
     // Bun's module resolver walks up from the plugin entry point
     // looking for `node_modules/`, and without entries there the
-    // plugin throws `Cannot find module 'zod' (+2 more)` at startup.
+    // plugin throws `Cannot find module 'zod'` at startup.
     //
     // The resolution logic lives in `cli/plugin-runtime-deps.mjs` and
     // is shared with the modern provisioner (`cli/provision.mjs`). It
@@ -479,46 +483,38 @@ async function promptGraphifyInstall() {
 }
 
 export async function runPostInstall() {
-  // v6.1.0 — Bizar is Cline-only. The legacy opencode-era
-  // `promptAndInstallOptional()` (plugin/dashboard presence probes)
-  // has been removed; `cli/provision.mjs:runProvision` covers the same
-  // surface via `runProvision({ mode: 'install' })`, which is the path
+  // v6.3.0 — Bizar is Claude Code-native. `cli/provision-claude.mjs:runProvision`
+  // covers the install/update/validate surface and is the primary path
   // used by `bizar install` and `bizar update`. This `runPostInstall`
-  // is now a thin Cline-only bootstrap that:
-  //   - copies `config/cline.json` template on first install
-  //   - runs `installCommandsBizar()` for the legacy `commands-bizar/` dir
-  //   - installs agents into `~/.cline/agents/`
+  // is a thin Claude Code-native bootstrap that:
+  //   - copies `config/settings.json` template on first install
+  //   - installs agents into `~/.claude/agents/`
   //   - probes for headroom / semble / skills-cli
   //   - installs Headroom via pip or npm
-  // The old OpenCode-era probes (`Plugin source present`,
-  // `Dashboard source present`) moved to `cli/doctor.mjs` as live checks.
   const { mkdirSync, copyFileSync, existsSync } = await import('node:fs');
   const { execSync } = await import('node:child_process');
 
-  const dest = join(clineConfigDir(), 'cline.json');
-  const templateSrc = repoPath('config', 'cline.json');
+  const dest = join(claudeConfigDir(), 'settings.json');
+  const templateSrc = repoPath('config', 'settings.json');
   if (!existsSync(dest)) {
     if (existsSync(templateSrc)) {
-      mkdirSync(clineConfigDir(), { recursive: true });
+      mkdirSync(claudeConfigDir(), { recursive: true });
       copyFileSync(templateSrc, dest);
-      console.log('  ✓ cline.json bootstrapped from package template');
+      console.log('  ✓ settings.json bootstrapped from package template');
     }
   }
 
-  // Install Bizar commands to commands-bizar/ (separate from ECC's commands symlink)
-  await installCommandsBizar();
-
-  const env = await detectCline();
+  const env = await detectClaude();
   if (!env.exists) {
-    mkdirSync(clineConfigDir(), { recursive: true });
-    console.log(`BizarHarness: created ${clineConfigDir()}/`);
+    mkdirSync(claudeConfigDir(), { recursive: true });
+    console.log(`BizarHarness: created ${claudeConfigDir()}/`);
   }
 
-  mkdirSync(clineAgentsDir(), { recursive: true });
+  mkdirSync(claudeAgentsDir(), { recursive: true });
 
   for (const file of AGENT_FILES) {
     const src = repoPath('config', 'agents', file);
-    const dest = join(clineAgentsDir(), file);
+    const dest = join(claudeAgentsDir(), file);
     if (!existsSync(dest)) {
       copyFileSync(src, dest);
     }
@@ -537,14 +533,14 @@ export async function runPostInstall() {
           'pip install --user "headroom-ai[all]"',
           { stdio: 'pipe', timeout: 60000 },
         );
-        execSync('headroom wrap cline', { stdio: 'pipe' });
+        execSync('headroom wrap claude', { stdio: 'pipe' });
         console.log('BizarHarness: Headroom installed and configured.');
       }
     } catch {
       // Fall back to npm
       try {
         execSync('npm install -g headroom-ai', { stdio: 'pipe', timeout: 60000 });
-        execSync('headroom wrap cline', { stdio: 'pipe' });
+        execSync('headroom wrap claude', { stdio: 'pipe' });
         console.log('BizarHarness: Headroom installed (npm) and configured.');
       } catch {
         console.log('BizarHarness: Headroom install failed. Install manually: pip install "headroom-ai[all]" or npm install -g headroom-ai');
@@ -552,10 +548,10 @@ export async function runPostInstall() {
     }
   } else {
     try {
-      execSync('headroom wrap cline', { stdio: 'pipe' });
-      console.log('BizarHarness: Headroom configured for cline.');
+      execSync('headroom wrap claude', { stdio: 'pipe' });
+      console.log('BizarHarness: Headroom configured for claude.');
     } catch {
-      console.log('BizarHarness: could not configure Headroom. Run `headroom wrap cline` manually.');
+      console.log('BizarHarness: could not configure Headroom. Run `headroom wrap claude` manually.');
     }
   }
 

package/cli/install.test.mjs

@@ -5,7 +5,7 @@
  * the node_modules copy step added in the "make the plugin-install fix
  * durable" change.
  *
- * Strategy: mock HOME so clineConfigDir() resolves inside a tmpdir,
+ * Strategy: mock HOME so claudeConfigDir() resolves inside a tmpdir,
  * and pass `opts.sourceDir` to bypass the `npm root -g` lookup with a
  * caller-supplied fake plugin source.
  *
@@ -31,25 +31,25 @@ const ORIG_HOME = process.env.HOME;
 const ORIG_XDG = process.env.XDG_CONFIG_HOME;
 
 /**
- * Point HOME at a fresh tmpdir so the module's clineConfigDir()
- * resolves inside it. As of v5.6.0-beta.12, `clineConfigDir()` returns
- * `<HOME>/.cline/` (matching Cline's own `resolveClineDir` since v3.0).
+ * Point HOME at a fresh tmpdir so the module's claudeConfigDir()
+ * resolves inside it. As of v6.3.0, `claudeConfigDir()` returns
+ * `<HOME>/.claude/`.
  *
- * We also reset CLINE_DIR and BIZAR_LEGACY_CLINE_DIR so the test uses
- * the canonical path even if the developer's env is non-default.
+ * We also reset CLAUDE_CONFIG_DIR and BIZAR_LEGACY_CLAUDE_DIR so the
+ * test uses the canonical path even if the developer's env is non-default.
  */
 function freshHome() {
   const home = mkdtempSync(join(tmpdir(), 'bizar-install-'));
   process.env.HOME = home;
   delete process.env.XDG_CONFIG_HOME;
-  delete process.env.CLINE_DIR;
-  delete process.env.BIZAR_LEGACY_CLINE_DIR;
+  delete process.env.CLAUDE_CONFIG_DIR;
+  delete process.env.BIZAR_LEGACY_CLAUDE_DIR;
   return home;
 }
 
 /** Path to the deployed plugin dir under the mocked HOME. */
 function pluginDest(home) {
-  return join(home, '.cline', 'plugins', 'bizar');
+  return join(home, '.claude', 'plugins', 'bizar');
 }
 
 /**

package/cli/memory-constants.mjs

@@ -19,6 +19,23 @@ export const VALID_TYPES = [
   'task_summary',
   'session_summary',
   'user_preference',
+  // v6.4.0 — F-033 ReasoningBank distillation pipeline (ADR-174).
+  // `pattern` is emitted by `bizar-dash/src/server/memory-consolidator.mjs`
+  // when a distillation run produces a promoted pattern (oracle:test-exec
+  // or judge:fable tier, ≥1 contributing entry). Patterns are searchable
+  // and re-feed into subsequent distillation runs as plain inputs.
+  'pattern',
+];
+
+export const VALID_PROVENANCE_TIERS = [
+  // Tier-1 (oracle) — observed via test execution. Eligible for promotion.
+  'oracle:test-exec',
+  // Tier-2 (proxy) — structural inference only. NOT eligible for
+  // promotion; written to the vault but `promoted: false`.
+  'proxy:structural',
+  // Tier-3 (judge:fable) — cost-bounded LLM-judge path; requires
+  // `BIZAR_DISTILL_BUDGET_USD > 0`. Out of scope in the $0 default.
+  'judge:fable',
 ];
 
 export const VALID_STATUSES = [