@rafinery/cli 0.8.0 → 0.8.2

package/lib/githook.mjs

@@ -1,54 +1,96 @@
-// The git pre-push hook installer — M5 sensor #3 (the deterministic checkpoint
-// boundary). `git push` of the code branch is a ratified natural checkpoint
-// moment; this hook makes it MECHANICAL instead of SOP-remembered.
+// The git hook installer — M5 sensor #3 (pre-push checkpoint boundary) plus
+// the capture-engine P1 transport hooks (post-commit 1-1 brain commits ·
+// post-checkout lockstep · post-rewrite rebase maps). "Brain git work is done
+// automatically; the dev never maintains the brain" — these installs are that
+// principle made mechanical.
 //
 // .git/hooks is per-clone (git never versions it), so this runs at init AND
-// pull (the teammate path) AND update — every working copy gets the sensor.
-// Never clobbers a foreign hook: ours is recognized by its marker line; anything
-// else is respected and the chain-line printed for the dev to add themselves.
+// pull (the teammate path) AND update — every working copy gets the sensors.
+// Never clobbers a foreign hook: ours is recognized by its marker line;
+// anything else is respected and the chain-line printed for the dev to add
+// themselves.
 
 import { chmodSync, copyFileSync, existsSync, readFileSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { join } from "node:path";
 
-const MARKER = "rafa pre-push hook";
-const CHAIN_LINE = "npx -y @rafinery/cli checkpoint || true";
+const HOOKS = [
+  {
+    name: "pre-push",
+    marker: "rafa pre-push hook",
+    chain: "npx -y @rafinery/cli checkpoint || true",
+  },
+  {
+    name: "post-commit",
+    marker: "rafa post-commit hook",
+    chain: 'node ".claude/rafa/hooks/brain-commit.mjs" || true',
+  },
+  {
+    name: "post-checkout",
+    marker: "rafa post-checkout hook",
+    chain: 'node ".claude/rafa/hooks/brain-switch.mjs" "$1" "$2" "$3" || true',
+  },
+  {
+    name: "post-rewrite",
+    marker: "rafa post-rewrite hook",
+    chain: 'node ".claude/rafa/hooks/brain-map.mjs" "$1" || true',
+  },
+];
 
-export function installPrePush(targetDir) {
-  const src = join(targetDir, ".claude", "rafa", "hooks", "pre-push");
-  if (!existsSync(src)) return { skipped: "no vendored hook template (run `rafa update`)" };
-
-  let hooksDir;
-  try {
-    // --git-path resolves worktrees/submodules correctly; never assume .git is a dir.
-    hooksDir = execSync("git rev-parse --git-path hooks", { cwd: targetDir, encoding: "utf8" }).trim();
-    hooksDir = join(targetDir, hooksDir);
-  } catch {
-    return { skipped: "not a git repo" };
-  }
-
-  const dst = join(hooksDir, "pre-push");
+function installOne(targetDir, hooksDir, { name, marker, chain }) {
+  const src = join(targetDir, ".claude", "rafa", "hooks", name);
+  if (!existsSync(src))
+    return { hook: name, skipped: "no vendored hook template (run `rafa update`)" };
+  const dst = join(hooksDir, name);
   if (existsSync(dst)) {
     const body = readFileSync(dst, "utf8");
-    if (!body.includes(MARKER)) {
+    if (!body.includes(marker))
       return {
+        hook: name,
         skipped:
-          "a pre-push hook already exists (not rafa's) — to chain the checkpoint boundary, " +
-          `add this line to it yourself:  ${CHAIN_LINE}`,
+          `a ${name} hook already exists (not rafa's) — to chain ours, add this ` +
+          `line to it yourself:  ${chain}`,
       };
-    }
-    // ours → refresh in place (idempotent update)
-    copyFileSync(src, dst);
+    copyFileSync(src, dst); // ours → refresh in place (idempotent update)
     chmodSync(dst, 0o755);
-    return { updated: true };
+    return { hook: name, updated: true };
   }
   copyFileSync(src, dst);
   chmodSync(dst, 0o755);
-  return { installed: true };
+  return { hook: name, installed: true };
 }
 
+export function installGitHooks(targetDir) {
+  let hooksDir;
+  try {
+    // --git-path resolves worktrees/submodules correctly; never assume .git is a dir.
+    hooksDir = execSync("git rev-parse --git-path hooks", {
+      cwd: targetDir,
+      encoding: "utf8",
+    }).trim();
+    hooksDir = join(targetDir, hooksDir);
+  } catch {
+    return HOOKS.map((h) => ({ hook: h.name, skipped: "not a git repo" }));
+  }
+  return HOOKS.map((h) => installOne(targetDir, hooksDir, h));
+}
+
+export function reportGitHooks(results) {
+  const fresh = results.filter((r) => r.installed).map((r) => r.hook);
+  const refreshed = results.filter((r) => r.updated).map((r) => r.hook);
+  if (fresh.length)
+    console.log(
+      `  ✓ git hooks installed: ${fresh.join(" · ")} — checkpoint at push, 1-1 brain commits, branch lockstep, rebase maps (all non-blocking)`,
+    );
+  if (refreshed.length) console.log(`  ✓ git hooks refreshed: ${refreshed.join(" · ")}`);
+  for (const r of results.filter((r) => r.skipped))
+    console.log(`  ! git ${r.hook} hook not installed — ${r.skipped}`);
+}
+
+// Back-compat for older callers: pre-push only.
+export function installPrePush(targetDir) {
+  return installGitHooks(targetDir).find((r) => r.hook === "pre-push");
+}
 export function reportGitHook(r) {
-  if (r.installed) console.log("  ✓ git pre-push hook → checkpoint runs at every code push (non-blocking)");
-  else if (r.updated) console.log("  ✓ git pre-push hook refreshed");
-  else if (r.skipped) console.log(`  ! git pre-push hook not installed — ${r.skipped}`);
+  reportGitHooks([r]);
 }

package/lib/init.mjs

@@ -120,8 +120,8 @@ export default async function init(args) {
   }
   // The pre-push checkpoint boundary is per-clone (.git/hooks is never committed).
   {
-    const { installPrePush, reportGitHook } = await import("./githook.mjs");
-    reportGitHook(installPrePush(TARGET));
+    const { installGitHooks, reportGitHooks } = await import("./githook.mjs");
+    reportGitHooks(installGitHooks(TARGET));
   }
   // Wire the repo's own MCP servers into the (owned) agent cards so subagents
   // can actually reach them (zero-command orchestration, 2026-07-12).
@@ -229,5 +229,17 @@ export default async function init(args) {
         : ""),
   );
 
+  // P0: prove the machinery init just wired — sensors, scripts, and the
+  // heartbeat round-trip — instead of hoping. Platform-wired inits run the
+  // proof now (advisory: init already succeeded; doctor names any fix);
+  // blueprint-only inits get the pointer for after the platform is wired.
+  if (p?.mcpUrl) {
+    console.log("");
+    const { runDoctor } = await import("./doctor.mjs");
+    await runDoctor(TARGET);
+  } else {
+    console.log("\n  · verify the capture machinery anytime:  npx @rafinery/cli doctor");
+  }
+
   await notifyIfBehind();
 }

package/lib/mcp-client.mjs

@@ -41,7 +41,11 @@ export function resolveMcp(cwd) {
   const creds = readJson(credentialsPath());
   const repoCreds = creds?.repos?.[repoId] ?? null;
 
+  // Track WHERE each value came from — auth failures name their sources so a
+  // wrong-platform mismatch (env override vs credentials vs .mcp.json) is
+  // self-diagnosing instead of a scavenger hunt (owner live-catch 2026-07-17).
   const key = process.env.RAFA_MCP_KEY || repoCreds?.key || null;
+  const keySource = process.env.RAFA_MCP_KEY ? "env RAFA_MCP_KEY" : "credentials.json";
   if (!key)
     throw new Error(
       `no agent key — set RAFA_MCP_KEY, or mint one on the platform (repo → Agent access) ` +
@@ -49,17 +53,21 @@ export function resolveMcp(cwd) {
     );
 
   let mcpUrl = process.env.RAFA_MCP_URL || repoCreds?.mcpUrl || null;
+  let urlSource = process.env.RAFA_MCP_URL ? "env RAFA_MCP_URL" : "credentials.json";
   if (!mcpUrl) {
     const mcpJson = readJson(join(cwd, ".mcp.json"));
     const url = mcpJson?.mcpServers?.rafinery?.url;
-    if (typeof url === "string" && url !== "") mcpUrl = url;
+    if (typeof url === "string" && url !== "") {
+      mcpUrl = url;
+      urlSource = ".mcp.json";
+    }
   }
   if (!mcpUrl)
     throw new Error(
       "no MCP endpoint — set RAFA_MCP_URL, or ensure .mcp.json carries the `rafinery` server entry",
     );
 
-  return { repoId, key, mcpUrl };
+  return { repoId, key, mcpUrl, keySource, urlSource };
 }
 
 let rpcId = 0;
@@ -67,7 +75,7 @@ let rpcId = 0;
 // Call one tool; returns the structured payload. Throws with the server's
 // message on transport or tool errors.
 export async function callTool(cwd, tool, args = {}) {
-  const { repoId, key, mcpUrl } = resolveMcp(cwd);
+  const { repoId, key, mcpUrl, keySource, urlSource } = resolveMcp(cwd);
   // A localhost platform is only reachable on the machine running the dev
   // server — on a CI runner it is a guaranteed dead end; say so up front
   // instead of a bare "fetch failed".
@@ -101,10 +109,19 @@ export async function callTool(cwd, tool, args = {}) {
         `check the URL (RAFA_MCP_URL / credentials.json / .mcp.json) and that the platform is deployed and reachable from here.`,
     );
   }
-  if (res.status === 401)
+  if (res.status === 401) {
+    let host = mcpUrl;
+    try {
+      host = new URL(mcpUrl).host;
+    } catch {
+      /* keep the raw url */
+    }
     throw new Error(
-      "agent key rejected (401) — revoked or wrong platform; mint a new one (repo → Agent access)",
+      `agent key rejected (401) by ${host} — the key (from ${keySource}) is not valid on that platform ` +
+        `(url from ${urlSource}): revoked, or minted on a DIFFERENT deployment. Keys are per-platform — ` +
+        `mint one on THIS platform (repo → Agent access), or point the url back at the platform that minted yours.`,
     );
+  }
   if (res.status === 429)
     throw new Error("rate limited (429) — back off and retry");
   if (!res.ok) throw new Error(`MCP endpoint returned HTTP ${res.status}`);

package/lib/okf.mjs

@@ -36,9 +36,19 @@ export default async function okf(args = []) {
   }
 
   if (sub === "check") {
-    const { conformant, checked, errors, warnings } = validateBundle(ROOT, {
+    const { conformant, empty, checked, errors, warnings } = validateBundle(ROOT, {
       exempt: RAFA_EXEMPT,
     });
+    // Zero files is ABSENCE, never conformance — a green over an empty root
+    // would be the silent-empty failure class (no assumed values, outward).
+    if (empty) {
+      console.error(
+        `✗ rafa okf check: no .md files under ${ROOT} — nothing to check.\n` +
+          `  Wrong --root? In a brain-repo clone the bundle IS the directory: --root=.\n` +
+          `  In a code repo the bundle is .rafa/ (lazy — \`rafa pull --full\` mirrors it).`,
+      );
+      process.exit(1);
+    }
     for (const e of errors) console.log(`✗ ${e.path} — ${e.rule}`);
     for (const w of warnings) console.log(`⚠ ${w.path} — ${w.rule}`);
     console.log(

package/lib/pull.mjs

@@ -35,8 +35,8 @@ export default async function pull(args = []) {
   // Every working copy gets the M5 checkpoint boundary (.git/hooks is per-clone —
   // pull IS the teammate path, so this is where a fresh clone gains the sensor).
   {
-    const { installPrePush, reportGitHook } = await import("./githook.mjs");
-    reportGitHook(installPrePush(ROOT));
+    const { installGitHooks, reportGitHooks } = await import("./githook.mjs");
+    reportGitHooks(installGitHooks(ROOT));
   }
 
   // Reachability + default branch — loud if the remote can't be reached.

package/lib/push.mjs

@@ -23,6 +23,33 @@ export default async function push(args = []) {
   const { rafaDir } = ensureBrainRepo(ROOT);
   const inRafa = inDir(rafaDir);
 
+  // Mirrored-branch era (capture-engine P1): push is a MAIN-branch act and the
+  // brain DEFAULT branch is its only target. If the working copy sits on a
+  // mirrored session branch (post-checkout lockstep), carry dirty surfaces
+  // there and switch first — a session branch's candidates must never ride an
+  // org-brain push.
+  const defaultBranch = remoteDefaultBranch(rafaDir);
+  try {
+    const cur = inRafa("git rev-parse --abbrev-ref HEAD");
+    if (cur !== defaultBranch) {
+      try {
+        inRafa("git add -A");
+        inRafa(
+          `git commit -q -m "brain(switch-carryover)" -m "switch-carryover-from: ${cur}"`,
+        );
+      } catch {
+        /* nothing dirty */
+      }
+      try {
+        inRafa(`git checkout -q ${defaultBranch}`);
+      } catch {
+        inRafa(`git checkout -q -b ${defaultBranch}`);
+      }
+    }
+  } catch {
+    /* unborn HEAD (fresh brain repo) — the branch -M below names it */
+  }
+
   // Anchor the brain to the current code HEAD.
   let codeSha = "unknown";
   try {
@@ -104,12 +131,50 @@ export default async function push(args = []) {
     );
 
   inRafa("git add -A");
+  // Descriptive commit (owner catch 2026-07-17: the history was a wall of
+  // identical "brain: scan"). Everything needed is already in scope — the
+  // manifest compile just wrote, the staged diff, the verb from the caller
+  // (--verb=scan|improve|build|distill; "update" when unstated). The
+  // "brain-for:" trailer paragraph is unchanged — provenance consumers key
+  // on it.
+  const verbArg = args.find((a) => a.startsWith("--verb="));
+  const verb = verbArg ? verbArg.slice("--verb=".length) : "update";
+  const subjectParts = [];
+  try {
+    const m = JSON.parse(readFileSync(join(rafaDir, "manifest.json"), "utf8"));
+    if (Array.isArray(m.notes)) subjectParts.push(`${m.notes.length} notes`);
+    if (Array.isArray(m.improvements)) {
+      const open = m.improvements.filter((i) => i.status === "open").length;
+      subjectParts.push(`${m.improvements.length} improvements (${open} open)`);
+    }
+    const h = m.health ?? {};
+    if (h.verdict) subjectParts.push(`health ${h.verdict}${typeof h.score === "number" ? ` ${h.score}` : ""}`);
+  } catch {
+    /* manifest unreadable — the verb + trailer still beat "brain: scan" */
+  }
+  let stagedStat = "";
   try {
-    inRafa(`git commit -m "brain: scan" -m "brain-for: ${codeSha}"`);
+    const lines = inRafa("git diff --cached --name-status")
+      .split("\n")
+      .filter(Boolean);
+    if (lines.length) {
+      const n = (p) => lines.filter((l) => l.startsWith(p)).length;
+      stagedStat = `files +${n("A")} ~${n("M")} -${n("D")}`;
+    }
+  } catch {
+    /* stat is garnish */
+  }
+  const subject = `brain(${verb}): ${
+    subjectParts.length ? subjectParts.join(" · ") : "state sync"
+  } · brain-for: ${codeSha}`.replace(/"/g, "'");
+  try {
+    inRafa(
+      `git commit -m "${subject}" -m "brain-for: ${codeSha}${stagedStat ? ` · ${stagedStat}` : ""} · cli: ${CLI_VERSION}"`,
+    );
   } catch {
     console.log("• nothing new to commit — pushing current state");
   }
-  const branch = remoteDefaultBranch(rafaDir);
+  const branch = defaultBranch;
   inRafa(`git branch -M ${branch}`);
   try {
     inRafa(`git push -u origin ${branch}`);

package/lib/releases.mjs

@@ -203,6 +203,32 @@ export const RELEASES = [
       "manifest shape + schemaVersion 1 + checker v2 — all additive " +
       "(§8); no re-scan, adopt with `rafa update`, then `rafa push` materializes the bundle.",
   },
+  {
+    version: "0.8.1",
+    contract: 1,
+    plans: 2,
+    requires: "update",
+    summary:
+      "Honest-empty patch: `rafa okf check` on a root with zero .md files now FAILS " +
+      "loudly (\"nothing to check\" + root guidance) instead of printing a vacuous " +
+      "conformance green — absence is never conformance. `rafa okf` (emit) on an empty " +
+      "root materializes nothing and returns 1 (push logs + continues past a lazy " +
+      ".rafa; standalone exits loud). @rafinery/okf 0.1.1: validateBundle gains the " +
+      "additive `empty` flag so library consumers can make the same distinction.",
+  },
+  {
+    version: "0.8.2",
+    contract: 1,
+    plans: 2,
+    requires: "update",
+    summary:
+      "MCP scope hygiene, fleet-wide. Server: `repo` is now OPTIONAL on every tool — " +
+      "derived from the per-repo key (an authenticated fact); explicit mismatch still " +
+      "fails loudly with guidance. Cards: every agent (atlas/bloom/prism/sage/compass/" +
+      "distiller) + the conductor now carry the calling convention — omit repo; where a " +
+      "value is needed it is rafa.json → repoId, never a folder-name guess. `rafa " +
+      "update` re-vendors the cards.",
+  },
 ];
 
 // The release this CLI build ships (last entry).

package/lib/sensor-health.mjs

@@ -0,0 +1,91 @@
+// Sensor-health inventory (capture-engine P0) — the same wired∧exists truth
+// `rafa status` prints, shaped for the platform heartbeat. Hooks fail SILENT
+// by design (never block a session); the heartbeat makes the ABSENCE visible
+// to the platform instead of only to a dev who thinks to ask.
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const queueLife = (file) => {
+  try {
+    const rows = readFileSync(file, "utf8").split("\n").filter(Boolean);
+    const last = rows.length ? JSON.parse(rows[rows.length - 1]) : null;
+    const t = last?.t ?? last?.at ?? null;
+    return { entries: rows.length, ...(typeof t === "number" ? { lastFireAt: t } : {}) };
+  } catch {
+    return { entries: 0 };
+  }
+};
+
+export function collectSensorHealth(root) {
+  const rafaDir = join(root, ".rafa");
+  let settings = null;
+  try {
+    settings = JSON.parse(
+      readFileSync(join(root, ".claude", "settings.json"), "utf8"),
+    );
+  } catch {
+    /* unwired repo — every hook reports wired: false below */
+  }
+  const wired = (event, script) => {
+    const entries = settings?.hooks?.[event] ?? [];
+    return (
+      JSON.stringify(entries).includes(`rafa/hooks/${script}`) &&
+      existsSync(join(root, ".claude", "rafa", "hooks", script))
+    );
+  };
+  // The git hooks are per-clone (installed by init/pull/update), so their
+  // wiring is checked in .git/hooks, not settings.json.
+  const gitHookWired = (name) => {
+    try {
+      return readFileSync(join(root, ".git", "hooks", name), "utf8").includes("rafa");
+    } catch {
+      return false;
+    }
+  };
+  // Swallowed failures the wrappers recorded (non-blocking by design, but the
+  // heartbeat still carries them — the platform sees what the terminal ate).
+  const lastErrorFor = (() => {
+    const byHook = new Map();
+    try {
+      for (const line of readFileSync(join(rafaDir, "sensor-errors.jsonl"), "utf8")
+        .split("\n")
+        .filter(Boolean)) {
+        const e = JSON.parse(line);
+        if (e?.hook) byHook.set(e.hook, e);
+      }
+    } catch {
+      /* no recorded errors */
+    }
+    return (name) => {
+      const e = byHook.get(name);
+      return e
+        ? {
+            ...(typeof e.error === "string" ? { lastError: e.error } : {}),
+            ...(typeof e.t === "number" ? { lastErrorAt: e.t } : {}),
+          }
+        : {};
+    };
+  })();
+  return {
+    reportedAt: Date.now(),
+    hooks: [
+      { name: "session-start", wired: wired("SessionStart", "session-start.mjs") },
+      {
+        name: "post-tool",
+        wired: wired("PostToolUse", "post-tool.mjs"),
+        ...queueLife(join(rafaDir, "dirty.jsonl")),
+      },
+      {
+        name: "user-prompt-submit",
+        wired: wired("UserPromptSubmit", "user-prompt-submit.mjs"),
+        ...queueLife(join(rafaDir, "reflex.jsonl")),
+      },
+      { name: "pre-push", wired: gitHookWired("pre-push"), ...lastErrorFor("pre-push") },
+      // Capture-engine P1 transport hooks — the brain's 1-1 mirror machinery.
+      { name: "post-commit", wired: gitHookWired("post-commit"), ...lastErrorFor("post-commit") },
+      { name: "post-checkout", wired: gitHookWired("post-checkout"), ...lastErrorFor("post-checkout") },
+      { name: "post-rewrite", wired: gitHookWired("post-rewrite"), ...lastErrorFor("post-rewrite") },
+    ],
+  };
+}

package/lib/status.mjs

@@ -105,7 +105,40 @@ export function computeStatus(root = process.cwd()) {
     }
   }
 
-  return { provisioned, plan, dirty, reflex, conflicts };
+  // Sensor health — hooks fail SILENT by design (never block a session), which
+  // means a broken sensor is invisible until someone asks. This makes asking
+  // one command (live-catch 2026-07-17: "it proves our hooks are not listening"
+  // was unfalsifiable without it). wired = settings.json carries the hook AND
+  // its script exists; lastWrite = the queue's own evidence of life.
+  const sensors = (() => {
+    const settings = (() => {
+      try {
+        return JSON.parse(readFileSync(join(root, ".claude", "settings.json"), "utf8"));
+      } catch {
+        return null;
+      }
+    })();
+    const hookWired = (event, script) => {
+      const entries = settings?.hooks?.[event] ?? [];
+      const inSettings = JSON.stringify(entries).includes(`rafa/hooks/${script}`);
+      return {
+        wired: inSettings && existsSync(join(root, ".claude", "rafa", "hooks", script)),
+      };
+    };
+    const lastLine = (file) => {
+      const rows = readJsonl(join(rafaDir, file));
+      const t = rows.length ? rows[rows.length - 1].t ?? rows[rows.length - 1].at ?? null : null;
+      return { entries: rows.length, lastWrite: t ?? null };
+    };
+    return {
+      settingsFound: settings !== null,
+      sessionStart: hookWired("SessionStart", "session-start.mjs"),
+      postTool: { ...hookWired("PostToolUse", "post-tool.mjs"), ...lastLine("dirty.jsonl") },
+      promptSubmit: { ...hookWired("UserPromptSubmit", "user-prompt-submit.mjs"), ...lastLine("reflex.jsonl") },
+    };
+  })();
+
+  return { provisioned, plan, dirty, reflex, conflicts, sensors };
 }
 
 // The ambient one-liner — identical semantics wherever it renders.
@@ -149,4 +182,17 @@ export default async function status(args = []) {
   if (s.conflicts) console.log(`  conflicts: ${s.conflicts} .theirs.md awaiting your decision`);
   if (!s.plan && !s.dirty && !s.reflex && !s.conflicts)
     console.log("  nothing pending — the loop is closed.");
+  // Sensors: broken hooks are silent by design — say their state out loud here.
+  const sen = s.sensors;
+  const mark = (h) => (h.wired ? "✓" : "✗ NOT WIRED");
+  console.log(
+    `  sensors: digest ${mark(sen.sessionStart)} · dirty-marker ${mark(sen.postTool)}` +
+      (sen.postTool.entries ? ` (${sen.postTool.entries} entries, last ${sen.postTool.lastWrite ?? "?"})` : " (queue empty)") +
+      ` · reflex ${mark(sen.promptSubmit)}` +
+      (sen.promptSubmit.entries ? ` (${sen.promptSubmit.entries})` : ""),
+  );
+  if (!sen.settingsFound || !sen.sessionStart.wired || !sen.postTool.wired || !sen.promptSubmit.wired)
+    console.log(
+      "  ⚠ sensor(s) not listening — edits/corrections are NOT being captured. `rafa update` re-merges the hooks into .claude/settings.json.",
+    );
 }

package/lib/update.mjs

@@ -48,8 +48,8 @@ export default async function update(args = []) {
     const sl = mergeStatusLine(TARGET);
     if (sl.skipped) console.log(`  ! statusline untouched — ${sl.skipped}`);
     else if (sl.added?.length) console.log("  ✓ loop-state statusline → .claude/settings.json");
-    const { installPrePush, reportGitHook } = await import("./githook.mjs");
-    reportGitHook(installPrePush(TARGET));
+    const { installGitHooks, reportGitHooks } = await import("./githook.mjs");
+    reportGitHooks(installGitHooks(TARGET));
   }
 
   // ── Blueprint-side migrations: mechanical/deterministic, run here in the CLI. ──

package/lib/working-set.mjs

@@ -26,7 +26,25 @@ import {
 import { dirname, join } from "node:path";
 
 // The working-set scan roots inside .rafa/ — brain-shaped authoring surfaces.
-export const WORKING_DIRS = ["brain/rules", "brain/playbooks"];
+// P2 typed candidates (capture-engine spec r2 §3): improvements ride as
+// candidates (files only — improve/ledger.md is DERIVED, regenerated at push,
+// never a candidate) and the post-commit hook's intent records travel as
+// provenance. The platform stores paths untyped; kind derives from the path.
+export const WORKING_DIRS = [
+  "brain/rules",
+  "brain/playbooks",
+  "improve/improvements",
+  "intent",
+];
+
+// The candidate kind a working-set path carries — the distiller's judge seam
+// and the fold's filters key on this, never on a parallel type field that
+// could drift from the path.
+export function kindOfPath(path) {
+  if (path.startsWith("improve/improvements/")) return "improvement";
+  if (path.startsWith("intent/")) return "intent";
+  return "note";
+}
 
 export const hashOf = (text) => createHash("sha256").update(text).digest("hex");
 

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@rafinery/cli",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "rafa — the AI engineer CLI. Vendors the rafa blueprint into your repo (shadcn-style) and runs the deterministic contract gates.",
   "type": "module",
   "bin": {
-    "rafa": "bin/rafa.mjs"
+    "rafa": "bin/rafa.mjs",
+    "rafa-distiller": "bin/rafa-distiller.mjs"
   },
   "files": [
     "bin",
@@ -16,11 +17,16 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@rafinery/okf": "0.1.0"
+    "@rafinery/okf": "workspace:*"
   },
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "bundle": "node scripts/bundle-blueprint.mjs",
+    "prepare": "node scripts/bundle-blueprint.mjs",
+    "test": "node --test"
+  },
   "keywords": [
     "rafa",
     "rafinery",
@@ -36,9 +42,5 @@
     "url": "git+https://github.com/rafinery-ai/rafinery.git",
     "directory": "packages/cli"
   },
-  "homepage": "https://github.com/rafinery-ai/rafinery/tree/main/packages/cli",
-  "scripts": {
-    "bundle": "node scripts/bundle-blueprint.mjs",
-    "test": "node --test"
-  }
-}
+  "homepage": "https://github.com/rafinery-ai/rafinery/tree/main/packages/cli"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (c) Atai Barkai
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.