bisque-cli 0.2.2 → 0.3.0

package/dist/index.js

@@ -776,9 +776,279 @@ import { createRequire } from "node:module";
 import { Command, Option as Option3 } from "commander";
 
 // src/commands/add.ts
-init_api_client();
 import { readFile as readFile2 } from "node:fs/promises";
 import { basename } from "node:path";
+
+// src/codebase-sync/provenance.ts
+var MAX_CODE_PATHS = 50;
+var MAX_PATH_LENGTH = 256;
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  // JS / TS
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "ts",
+  "tsx",
+  "mts",
+  "cts",
+  // Other languages
+  "py",
+  "rb",
+  "php",
+  "go",
+  "rs",
+  "java",
+  "kt",
+  "kts",
+  "scala",
+  "swift",
+  "dart",
+  "lua",
+  "r",
+  "ex",
+  "exs",
+  "erl",
+  "clj",
+  "cljs",
+  // C family
+  "c",
+  "h",
+  "cc",
+  "cpp",
+  "cxx",
+  "hpp",
+  "hh",
+  "m",
+  "mm",
+  "cs",
+  // Shell / query / schema
+  "sh",
+  "bash",
+  "zsh",
+  "sql",
+  "graphql",
+  "gql",
+  "proto",
+  // Config / data
+  "json",
+  "jsonc",
+  "json5",
+  "yaml",
+  "yml",
+  "toml",
+  "ini",
+  "xml",
+  "tf",
+  "gradle",
+  // Web
+  "css",
+  "scss",
+  "sass",
+  "less",
+  "html",
+  "vue",
+  "svelte",
+  "astro",
+  // Docs
+  "md",
+  "mdx"
+]);
+function stripWrappers(s) {
+  return s.replace(/^['"`<]+/, "").replace(/['"`>]+$/, "");
+}
+function normalizePath(raw) {
+  let p = stripWrappers(raw.trim());
+  if (!p) return null;
+  p = p.replace(/\\/g, "/");
+  p = p.replace(/[#?].*$/, "");
+  p = p.replace(/^\.\//, "");
+  p = p.replace(/^\/+/, "");
+  p = p.replace(/\/{2,}/g, "/");
+  p = p.replace(/\/+$/, "");
+  p = p.trim();
+  if (!p || p.length > MAX_PATH_LENGTH) return null;
+  return p;
+}
+function hasSourceExtension(p) {
+  const base = p.slice(p.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return false;
+  return SOURCE_EXTENSIONS.has(base.slice(dot + 1).toLowerCase());
+}
+function isExternalUrl(s) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(s) || s.startsWith("mailto:") || s.startsWith("//");
+}
+function dedupCap(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of paths) {
+    if (seen.has(p)) continue;
+    seen.add(p);
+    out.push(p);
+    if (out.length >= MAX_CODE_PATHS) break;
+  }
+  return out;
+}
+function splitList(raw) {
+  let t = raw.trim();
+  if (t.startsWith("[") && t.endsWith("]")) t = t.slice(1, -1);
+  return t.split(",").map((x) => stripWrappers(x.trim())).filter(Boolean);
+}
+function frontmatterEndLine(lines) {
+  if (lines.length === 0 || lines[0]?.trim() !== "---") return -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") return i;
+  }
+  return -1;
+}
+function collectBlockList(lines, start, end) {
+  const items = [];
+  for (let j = start; j < end; j++) {
+    const itm = (lines[j] ?? "").match(/^\s*-\s+(.*)$/);
+    if (!itm) break;
+    const v = stripWrappers((itm[1] ?? "").trim());
+    if (v) items.push(v);
+  }
+  return items;
+}
+function collectFrontmatter(lines) {
+  const end = frontmatterEndLine(lines);
+  if (end < 0) return [];
+  for (let i = 1; i < end; i++) {
+    const m = (lines[i] ?? "").match(/^\s*codePaths\s*:\s*(.*)$/);
+    if (!m) continue;
+    const inline = (m[1] ?? "").trim();
+    return inline ? splitList(inline) : collectBlockList(lines, i + 1, end);
+  }
+  return [];
+}
+function collectSentinels(content) {
+  const out = [];
+  const re = /<!--\s*bisque-code-paths\s*:\s*([\s\S]*?)\s*-->/g;
+  let m = re.exec(content);
+  while (m !== null) {
+    out.push(...splitList(m[1] ?? ""));
+    m = re.exec(content);
+  }
+  return out;
+}
+function fenceTokenPath(token) {
+  const candidates = [];
+  const eq = token.lastIndexOf("=");
+  if (eq >= 0) candidates.push(token.slice(eq + 1));
+  const colon = token.lastIndexOf(":");
+  if (colon >= 0) candidates.push(token.slice(colon + 1));
+  candidates.push(token);
+  for (const cand of candidates) {
+    const p = normalizePath(cand);
+    if (p && hasSourceExtension(p)) return p;
+  }
+  return null;
+}
+function fenceInfoPaths(info) {
+  const out = [];
+  for (const token of info.split(/\s+/)) {
+    const p = fenceTokenPath(token);
+    if (p) out.push(p);
+  }
+  return out;
+}
+function scanLinks(line) {
+  const out = [];
+  const re = /\]\(\s*<?([^)\s>]+)>?[^)]*\)/g;
+  let m = re.exec(line);
+  while (m !== null) {
+    const target = m[1] ?? "";
+    if (!isExternalUrl(target) && !target.startsWith("#")) {
+      const p = normalizePath(target);
+      if (p && hasSourceExtension(p)) out.push(p);
+    }
+    m = re.exec(line);
+  }
+  return out;
+}
+function scanInline(line) {
+  const out = [];
+  const re = /`([^`\n]+)`/g;
+  let m = re.exec(line);
+  while (m !== null) {
+    const raw = (m[1] ?? "").trim();
+    if (raw && !/\s/.test(raw) && !isExternalUrl(raw)) {
+      const p = normalizePath(raw);
+      if (p && hasSourceExtension(p)) out.push(p);
+    }
+    m = re.exec(line);
+  }
+  return out;
+}
+function parseFenceMarker(line) {
+  const open = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
+  if (!open) return null;
+  const marker = open[1] ?? "";
+  return { ch: marker[0] ?? "", len: marker.length, info: (open[2] ?? "").trim() };
+}
+function applyFenceMarker(marker, state) {
+  if (!state.inFence) {
+    state.inFence = true;
+    state.char = marker.ch;
+    state.len = marker.len;
+    return marker.info ? fenceInfoPaths(marker.info) : [];
+  }
+  if (marker.ch === state.char && marker.len >= state.len && marker.info === "") {
+    state.inFence = false;
+    state.char = "";
+    state.len = 0;
+  }
+  return [];
+}
+function scanBody(lines, startLine) {
+  const fence = [];
+  const link = [];
+  const inline = [];
+  const state = { char: "", len: 0, inFence: false };
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const marker = parseFenceMarker(line);
+    if (marker) {
+      fence.push(...applyFenceMarker(marker, state));
+      continue;
+    }
+    if (state.inFence) continue;
+    link.push(...scanLinks(line));
+    inline.push(...scanInline(line));
+  }
+  return { fence, link, inline };
+}
+function normalizeCodePaths(paths) {
+  const normalized = [];
+  for (const raw of paths) {
+    const p = normalizePath(raw);
+    if (p) normalized.push(p);
+  }
+  return dedupCap(normalized);
+}
+function extractCodePaths(content) {
+  if (!content) return [];
+  const lines = content.split(/\r?\n/);
+  const declared = [...collectSentinels(content), ...collectFrontmatter(lines)];
+  if (declared.length > 0) return normalizeCodePaths(declared);
+  const fmEnd = frontmatterEndLine(lines);
+  const body = scanBody(lines, fmEnd >= 0 ? fmEnd + 1 : 0);
+  return dedupCap([...body.fence, ...body.link, ...body.inline]);
+}
+function resolveCodePaths(explicit, metadata, content) {
+  if (explicit !== void 0) {
+    const norm = normalizeCodePaths(explicit);
+    return norm.length > 0 ? norm : void 0;
+  }
+  if (metadata && metadata["codePaths"] !== void 0) return void 0;
+  const auto = extractCodePaths(content);
+  return auto.length > 0 ? auto : void 0;
+}
+
+// src/commands/add.ts
+init_api_client();
 function slugify(name) {
   return name.trim().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-_]/g, "");
 }
@@ -829,14 +1099,20 @@ async function resolveContent(file, options) {
 function parseDocIdList(val) {
   return val.split(",").map((s) => s.trim()).filter(Boolean);
 }
+function mergeCodePaths(metadata, options, content) {
+  const codePaths = resolveCodePaths(options.codePaths, metadata, content);
+  if (!codePaths) return metadata;
+  return { ...metadata ?? {}, codePaths };
+}
 function buildCreateBody(resolved, filepath, category, options, metadata) {
+  const finalMetadata = mergeCodePaths(metadata, options, resolved.content);
   return {
     title: resolved.title,
     filepath,
     category,
     tags: options.tags ?? [],
     content: resolved.content,
-    ...metadata && { metadata },
+    ...finalMetadata && { metadata: finalMetadata },
     // Freshness & Staleness v1 (T3). Pass through verbatim; backend
     // enum gates `status`, supersedes array is accepted on create.
     ...options.status !== void 0 && { status: options.status },
@@ -848,7 +1124,11 @@ function registerAddCommand(program2) {
     "-t, --tags <tags>",
     "Comma-separated tags",
     (val) => val.split(",").map((t) => t.trim())
-  ).option("--filepath <path>", "Explicit PARA filepath (overrides --project/--area/--resource)").option("--content <text>", "Inline content (skip file reading)").option("--title <name>", "Document title (required with --content)").option("--metadata <json>", "JSON metadata object").option("--status <status>", "Lifecycle state: live | superseded | archived. Defaults to live.").option(
+  ).option("--filepath <path>", "Explicit PARA filepath (overrides --project/--area/--resource)").option("--content <text>", "Inline content (skip file reading)").option("--title <name>", "Document title (required with --content)").option("--metadata <json>", "JSON metadata object").option(
+    "--code-paths <paths>",
+    "Comma-separated source paths this doc describes (overrides auto-extraction)",
+    parseDocIdList
+  ).option("--status <status>", "Lifecycle state: live | superseded | archived. Defaults to live.").option(
     "--supersedes <docIds>",
     "Comma-separated doc UUIDs this doc supersedes. Optional on create.",
     parseDocIdList
@@ -890,6 +1170,7 @@ function registerAddCommand(program2) {
 
 // src/agents-md/sections.ts
 var KEYWORDS_SENTINEL = "<!-- bisque-keywords:mechanical -->";
+var STATUS_SENTINEL = "<!-- bisque-status:mechanical -->";
 var CONTENT_EXTRACT_TARGET = 280;
 var CONTENT_EXTRACT_HARD_MAX = 400;
 function normalizeDir(dirPath) {
@@ -1073,6 +1354,45 @@ _(no keywords)_`;
 ${KEYWORDS_SENTINEL}
 ${bullets}`;
 }
+function asNonEmptyString(v) {
+  if (typeof v !== "string") return void 0;
+  const t = v.trim();
+  return t.length > 0 ? t : void 0;
+}
+function toAbsoluteDate(v) {
+  const s = asNonEmptyString(v);
+  if (!s) return void 0;
+  const m = /^(\d{4}-\d{2}-\d{2})/.exec(s);
+  return m ? m[1] : s;
+}
+function toShortSha(v) {
+  const s = asNonEmptyString(v);
+  if (!s) return void 0;
+  return s.length > 7 ? s.slice(0, 7) : s;
+}
+function toDriftCount(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : Number.NaN;
+  if (!Number.isFinite(n)) return void 0;
+  const i = Math.floor(n);
+  return i >= 1 ? i : void 0;
+}
+function generateStatusSection(metadata) {
+  const date = toAbsoluteDate(metadata?.["lastDistilledAt"]);
+  const sha = toShortSha(metadata?.["codeWatermark"]);
+  const count = toDriftCount(metadata?.["driftFlaggedCount"]);
+  let line;
+  if (!date) {
+    line = "Context not yet synced.";
+  } else {
+    line = sha ? `Context synced ${date} @ ${sha}.` : `Context synced ${date}.`;
+    if (count !== void 0) {
+      line += ` ${count} ${count === 1 ? "doc" : "docs"} flagged for review.`;
+    }
+  }
+  return `## Status
+${STATUS_SENTINEL}
+${line}`;
+}
 
 // src/agents-md/merge.ts
 var IF_WORKING_HERE_TITLE = "If you're working here";
@@ -1453,11 +1773,17 @@ function composeAgentsContent(dir, items) {
   });
   const existingDoc = items.find((d) => d.filepath === `${dir}AGENTS.md`);
   const header = generateHeader(dir);
-  const mechanicals = `${generateWhatsHereSection(dir, docs)}
+  let mechanicals = `${generateWhatsHereSection(dir, docs)}
 
 ${generateSubdirectoriesSection(dir, docs)}
 
 ${generateKeywordsSection(inDirDocs)}`;
+  const statusDoc = items.find((d) => d.filepath === `${dir}frontmind/status.md`);
+  if (statusDoc) {
+    mechanicals += `
+
+${generateStatusSection(statusDoc.metadata)}`;
+  }
   const nextContent = mergeAgentsMd(existingDoc?.content ?? null, header, mechanicals);
   return nextContent;
 }
@@ -2222,9 +2548,418 @@ function registerDeleteCommand(program2) {
   });
 }
 
-// src/commands/get.ts
-import { writeFile as writeFile2 } from "node:fs/promises";
-import { Option } from "commander";
+// src/commands/drift.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import chalk3 from "chalk";
+import Table2 from "cli-table3";
+
+// src/codebase-sync/drift-digest.ts
+var DIGEST_TOP_K = 25;
+var DIGEST_EVIDENCE_CAP = 3;
+var DIGEST_TOKEN_BUDGET = 2e3;
+function estimateTokens(value) {
+  return Math.ceil(JSON.stringify(value).length / 4);
+}
+function buildDigest(ranked, opts) {
+  const eligible = ranked.filter((d) => d.score > 0);
+  const top = eligible.slice(0, DIGEST_TOP_K);
+  const counts = {
+    scored: ranked.length,
+    forced: ranked.filter((d) => d.linkRot || d.breaking).length,
+    shown: top.length,
+    noProvenance: ranked.filter((d) => !d.hasProvenance).length
+  };
+  const makeRows = (evidenceCap) => top.map((d) => ({
+    filepath: d.filepath,
+    signal: d.signal,
+    evidence: d.evidence.slice(0, evidenceCap)
+  }));
+  const digest = {
+    schema: "bisque-drift/v1",
+    project: opts.project,
+    generatedAt: opts.generatedAt,
+    watermark: { since: opts.watermarkSince, head: opts.headShort },
+    lastDistilledAt: opts.lastDistilledAt,
+    rows: makeRows(DIGEST_EVIDENCE_CAP),
+    uncovered: opts.uncovered,
+    counts
+  };
+  for (let cap = DIGEST_EVIDENCE_CAP - 1; cap >= 0 && estimateTokens(digest) > DIGEST_TOKEN_BUDGET; cap -= 1) {
+    digest.rows = makeRows(cap);
+  }
+  return digest;
+}
+
+// src/codebase-sync/drift-scoring.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var HALF_LIFE_MS = {
+  inbox: 14 * DAY_MS,
+  project: 180 * DAY_MS,
+  area: 365 * DAY_MS,
+  resource: null,
+  archive: null,
+  other: null
+};
+var LINK_ROT_WEIGHT = 2;
+var BREAKING_WEIGHT = 4;
+var UNCOVERED_CAP = 10;
+function getCodePaths(doc) {
+  const raw = doc.metadata?.["codePaths"];
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((p) => typeof p === "string" && p.length > 0);
+}
+function paraBucket(filepath) {
+  const lower = filepath.toLowerCase();
+  if (lower.startsWith("0-inbox/") || lower.startsWith("inbox/")) return "inbox";
+  if (lower.startsWith("1-projects/") || lower.startsWith("projects/")) return "project";
+  if (lower.startsWith("2-areas/") || lower.startsWith("areas/")) return "area";
+  if (lower.startsWith("3-resources/") || lower.startsWith("resources/")) return "resource";
+  if (lower.startsWith("4-archives/") || lower.startsWith("4-archive/") || lower.startsWith("archive/")) {
+    return "archive";
+  }
+  return "other";
+}
+function isDatedRecordPath(filepath) {
+  const lower = filepath.toLowerCase();
+  if (lower.includes("backmind/chain-runs/")) return true;
+  if (lower.includes("0-inbox/autonomous-decisions/")) return true;
+  if (lower.includes("/tasks/") || lower.startsWith("tasks/")) return true;
+  if (lower === "agents.md" || lower.endsWith("/agents.md")) return true;
+  if (lower.endsWith("frontmind/status.md")) return true;
+  if (lower.includes("backmind/designs/")) return true;
+  if (lower.includes("backmind/reviews/")) return true;
+  if (lower.includes("backmind/decisions/")) return true;
+  if (lower.includes("backmind/research/")) return true;
+  return false;
+}
+function timeDecayStaleness(doc, nowMs) {
+  const halfLife = HALF_LIFE_MS[paraBucket(doc.filepath)] ?? null;
+  if (halfLife === null) return 0;
+  const lastDistilled = doc.metadata?.["lastDistilledAt"];
+  const anchor = (typeof lastDistilled === "string" ? lastDistilled : void 0) ?? doc.updatedAt ?? doc.createdAt;
+  if (!anchor) return 0;
+  const tsMs = Date.parse(anchor);
+  if (Number.isNaN(tsMs)) return 0;
+  const dt = Math.max(0, nowMs - tsMs);
+  return 1 - 0.5 ** (dt / halfLife);
+}
+function isVirtualDocPath(p) {
+  const lower = p.toLowerCase();
+  if (lower.startsWith("frontmind/") || lower.startsWith("backmind/")) return true;
+  return /^[0-4]-(inbox|projects|areas|resources|archives?)\//.test(lower);
+}
+function detectLinkRot(codePaths, headFiles) {
+  return codePaths.filter((p) => !isVirtualDocPath(p) && !headFiles.has(p));
+}
+function detectBreaking(codePaths, breakingTouched) {
+  return codePaths.filter((p) => breakingTouched.has(p));
+}
+function computeChurn(codePaths, numstatByPath) {
+  let total = 0;
+  for (const p of codePaths) {
+    const ns = numstatByPath.get(p);
+    if (ns) total += ns.added + ns.deleted;
+  }
+  return total;
+}
+function scoreDoc(doc, ctx) {
+  const codePaths = getCodePaths(doc);
+  const hasProvenance = codePaths.length > 0;
+  const linkRotPaths = hasProvenance ? detectLinkRot(codePaths, ctx.headFiles) : [];
+  const breakingPaths = hasProvenance ? detectBreaking(codePaths, ctx.breakingTouched) : [];
+  const staleness = timeDecayStaleness(doc, ctx.nowMs);
+  const linkRot = linkRotPaths.length > 0;
+  const breaking = breakingPaths.length > 0;
+  const score = staleness + (linkRot ? LINK_ROT_WEIGHT : 0) + (breaking ? BREAKING_WEIGHT : 0);
+  const signal = breaking ? "breaking" : linkRot ? "link-rot" : "time-decay";
+  const evidence = breaking ? breakingPaths : linkRot ? linkRotPaths : [];
+  const churn = ctx.churnEnabled && ctx.numstatByPath && !isDatedRecordPath(doc.filepath) ? computeChurn(codePaths, ctx.numstatByPath) : -1;
+  return {
+    filepath: doc.filepath,
+    score,
+    signal,
+    evidence,
+    hasProvenance,
+    linkRot,
+    breaking,
+    staleness,
+    churn
+  };
+}
+function scoreAndRank(docs, ctx) {
+  return docs.map((d) => scoreDoc(d, ctx)).sort((a, b) => b.score - a.score || a.filepath.localeCompare(b.filepath));
+}
+var DEFAULT_EXCLUDES = [
+  // build / vendored output dirs
+  "**/dist/**",
+  "**/build/**",
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/out/**",
+  // lockfiles
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lockb",
+  "Cargo.lock",
+  "poetry.lock",
+  "Gemfile.lock",
+  "composer.lock",
+  "go.sum",
+  // generated
+  "*.min.js",
+  "*.map",
+  "*.snap"
+];
+var REGEX_SPECIALS = /* @__PURE__ */ new Set([".", "+", "^", "$", "{", "}", "(", ")", "|", "[", "]", "\\"]);
+function expandStar(pat, i) {
+  if (pat[i + 1] === "*") {
+    if (pat[i + 2] === "/") return { frag: "(?:.*/)?", next: i + 3 };
+    return { frag: ".*", next: i + 2 };
+  }
+  return { frag: "[^/]*", next: i + 1 };
+}
+function globBodyToRegex(pat) {
+  let out = "";
+  let i = 0;
+  while (i < pat.length) {
+    const c = pat[i] ?? "";
+    if (c === "*") {
+      const { frag, next } = expandStar(pat, i);
+      out += frag;
+      i = next;
+    } else if (c === "?") {
+      out += "[^/]";
+      i += 1;
+    } else {
+      out += REGEX_SPECIALS.has(c) ? `\\${c}` : c;
+      i += 1;
+    }
+  }
+  return out;
+}
+function patternToRegex(pattern) {
+  let pat = pattern.trim();
+  if (!pat || pat.startsWith("#")) return null;
+  if (pat.endsWith("/")) pat = pat.slice(0, -1);
+  const anchored = pat.startsWith("/");
+  if (anchored) pat = pat.slice(1);
+  const body = globBodyToRegex(pat);
+  const startsAnywhere = !anchored && !pat.includes("/");
+  const prefix = startsAnywhere ? "^(?:.*/)?" : "^";
+  return new RegExp(`${prefix}${body}(?:/.*)?$`);
+}
+function createIgnoreMatcher(bisqueignoreContent) {
+  const lines = bisqueignoreContent ? bisqueignoreContent.split(/\r?\n/) : [];
+  const regexes = [...DEFAULT_EXCLUDES, ...lines].map(patternToRegex).filter((r) => r !== null);
+  return (path2) => regexes.some((re) => re.test(path2));
+}
+function buildUncoveredHint(addedPaths, allCodePaths, isIgnored, cap = UNCOVERED_CAP) {
+  const candidates = [...new Set(addedPaths)].filter((p) => hasSourceExtension(p) && !allCodePaths.has(p) && !isIgnored(p)).sort((a, b) => a.localeCompare(b));
+  const files = candidates.slice(0, cap);
+  return { files, more: Math.max(0, candidates.length - cap) };
+}
+
+// src/codebase-sync/git-drift.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var RS = "";
+var US = "";
+var EOM = "";
+var PRETTY_FORMAT = `format:${RS}%H${US}%cd${US}%B${EOM}`;
+var DEFAULT_FIRST_RUN_COMMITS = 200;
+var GIT_MAX_BUFFER = 64 * 1024 * 1024;
+function isBreakingMessage(message) {
+  const subject = (message.split(/\r?\n/, 1)[0] ?? "").trim();
+  if (/^[a-zA-Z][a-zA-Z0-9]*(\([^)]*\))?!:/.test(subject)) return true;
+  return /(^|\n)BREAKING[ -]CHANGE:/.test(message);
+}
+function normalizeGitPath(raw) {
+  let p = raw.trim();
+  if (p.startsWith('"') && p.endsWith('"') && p.length >= 2) p = p.slice(1, -1);
+  p = p.replace(/^\.\//, "").replace(/\/{2,}/g, "/");
+  return p.trim();
+}
+function resolveNumstatPath(field) {
+  let f = field.trim();
+  if (f.startsWith('"') && f.endsWith('"') && f.length >= 2) f = f.slice(1, -1);
+  if (f.includes(" => ")) {
+    const brace = f.match(/^(.*)\{(.*) => (.*)\}(.*)$/);
+    if (brace) {
+      f = `${brace[1] ?? ""}${brace[3] ?? ""}${brace[4] ?? ""}`;
+    } else {
+      const parts = f.split(" => ");
+      f = parts[parts.length - 1] ?? f;
+    }
+  }
+  return normalizeGitPath(f);
+}
+function parseLsTree(raw) {
+  const set = /* @__PURE__ */ new Set();
+  for (const line of raw.split(/\r?\n/)) {
+    const p = normalizeGitPath(line);
+    if (p) set.add(p);
+  }
+  return set;
+}
+function parseDiffLine(line) {
+  const ns = line.match(/^(-|\d+)\t(-|\d+)\t(.+)$/);
+  if (ns) {
+    const path2 = resolveNumstatPath(ns[3] ?? "");
+    if (!path2) return null;
+    const added = ns[1] === "-" ? 0 : Number.parseInt(ns[1] ?? "0", 10);
+    const deleted = ns[2] === "-" ? 0 : Number.parseInt(ns[2] ?? "0", 10);
+    return { kind: "numstat", path: path2, added, deleted };
+  }
+  const created = line.match(/^ create mode \d+ (.+)$/);
+  if (created) {
+    const path2 = normalizeGitPath(created[1] ?? "");
+    return path2 ? { kind: "created", path: path2 } : null;
+  }
+  return null;
+}
+function parseRecord(rec) {
+  const eom = rec.indexOf(EOM);
+  if (eom < 0) return null;
+  const head = rec.slice(0, eom);
+  const us1 = head.indexOf(US);
+  const us2 = head.indexOf(US, us1 + 1);
+  if (us1 < 0 || us2 < 0) return null;
+  const sha = head.slice(0, us1).trim();
+  const committerDate = head.slice(us1 + 1, us2).trim();
+  const body = head.slice(us2 + 1);
+  const touchedPaths = [];
+  const added = [];
+  const numstat = [];
+  for (const line of rec.slice(eom + 1).split(/\r?\n/)) {
+    const parsed = parseDiffLine(line);
+    if (!parsed) continue;
+    if (parsed.kind === "numstat") {
+      touchedPaths.push(parsed.path);
+      numstat.push({ path: parsed.path, added: parsed.added, deleted: parsed.deleted });
+    } else {
+      added.push(parsed.path);
+    }
+  }
+  return {
+    commit: {
+      sha,
+      shortSha: sha.slice(0, 7),
+      committerDate,
+      subject: (body.split(/\r?\n/, 1)[0] ?? "").trim(),
+      body,
+      breaking: isBreakingMessage(body),
+      touchedPaths
+    },
+    added,
+    numstat
+  };
+}
+function parseGitLog(raw) {
+  const commits = [];
+  const addedPaths = /* @__PURE__ */ new Set();
+  const numstatByPath = /* @__PURE__ */ new Map();
+  if (!raw) return { commits, addedPaths: [], numstatByPath };
+  for (const rec of raw.split(RS)) {
+    if (!rec) continue;
+    const parsed = parseRecord(rec);
+    if (!parsed) continue;
+    commits.push(parsed.commit);
+    for (const p of parsed.added) addedPaths.add(p);
+    for (const ns of parsed.numstat) {
+      const prev = numstatByPath.get(ns.path) ?? { path: ns.path, added: 0, deleted: 0 };
+      prev.added += ns.added;
+      prev.deleted += ns.deleted;
+      numstatByPath.set(ns.path, prev);
+    }
+  }
+  return { commits, addedPaths: [...addedPaths], numstatByPath };
+}
+async function runGit(cwd, args) {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd,
+    env: { ...process.env, TZ: "UTC" },
+    maxBuffer: GIT_MAX_BUFFER
+  });
+  return stdout;
+}
+function buildLogArgs(range, pathspec) {
+  const args = [
+    "log",
+    "--numstat",
+    "--summary",
+    "-M",
+    "--date=iso-strict-local",
+    `--pretty=${PRETTY_FORMAT}`,
+    ...range
+  ];
+  if (pathspec.length > 0) args.push("--", ...pathspec);
+  return args;
+}
+async function loadGitContext(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const pathspec = opts.pathspec ?? [];
+  const maxCommits = opts.maxCommits ?? DEFAULT_FIRST_RUN_COMMITS;
+  let headSha;
+  try {
+    headSha = (await runGit(cwd, ["rev-parse", "HEAD"])).trim();
+  } catch {
+    return emptyContext(false, null);
+  }
+  const lsTreeRaw = await runGit(cwd, ["ls-tree", "-r", "--name-only", "HEAD"]);
+  const headFiles = parseLsTree(lsTreeRaw);
+  const firstRunRange = ["-n", String(maxCommits), "HEAD"];
+  let isFirstRun = !opts.watermarkSha;
+  let watermarkFellBack = false;
+  let logRaw = "";
+  if (opts.watermarkSha) {
+    try {
+      logRaw = await runGit(cwd, buildLogArgs([`${opts.watermarkSha}..HEAD`], pathspec));
+    } catch {
+      isFirstRun = true;
+      watermarkFellBack = true;
+      logRaw = await runGit(cwd, buildLogArgs(firstRunRange, pathspec));
+    }
+  } else {
+    logRaw = await runGit(cwd, buildLogArgs(firstRunRange, pathspec));
+  }
+  const parsed = parseGitLog(logRaw);
+  const breakingTouchedPaths = /* @__PURE__ */ new Set();
+  for (const c of parsed.commits) {
+    if (!c.breaking) continue;
+    for (const p of c.touchedPaths) breakingTouchedPaths.add(p);
+  }
+  return {
+    isRepo: true,
+    isFirstRun,
+    watermarkFellBack,
+    headSha,
+    headShaShort: headSha.slice(0, 7),
+    watermarkSha: watermarkFellBack ? null : opts.watermarkSha,
+    headFiles,
+    commits: parsed.commits,
+    breakingTouchedPaths,
+    addedPaths: parsed.addedPaths,
+    numstatByPath: parsed.numstatByPath
+  };
+}
+function emptyContext(isRepo, watermarkSha) {
+  return {
+    isRepo,
+    isFirstRun: !watermarkSha,
+    watermarkFellBack: false,
+    headSha: "",
+    headShaShort: "",
+    watermarkSha,
+    headFiles: /* @__PURE__ */ new Set(),
+    commits: [],
+    breakingTouchedPaths: /* @__PURE__ */ new Set(),
+    addedPaths: [],
+    numstatByPath: /* @__PURE__ */ new Map()
+  };
+}
 
 // src/measure.ts
 import { appendFileSync, mkdirSync } from "node:fs";
@@ -2327,7 +3062,277 @@ function recordMeasurement(command, args, charsReturned) {
   }
 }
 
+// src/commands/drift.ts
+init_api_client();
+
+// src/utils/list-documents.ts
+async function fetchAllDocumentsMetadata(client, options) {
+  const pageLimit = options?.pageLimit ?? 100;
+  const maxPages = options?.maxPages ?? 1e3;
+  const all = [];
+  let cursor;
+  let pages = 0;
+  do {
+    const params = new URLSearchParams();
+    params.set("view", "metadata");
+    params.set("limit", String(pageLimit));
+    if (options?.pathPrefix) {
+      params.set("pathPrefix", options.pathPrefix);
+    }
+    if (options?.workspace) {
+      params.set("workspace", options.workspace);
+    }
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+    const response = await client.get(
+      `/v1/documents?${params.toString()}`
+    );
+    all.push(...response.items ?? []);
+    cursor = response.cursor;
+    pages += 1;
+  } while (cursor && pages < maxPages);
+  return all;
+}
+
+// src/commands/drift.ts
+var RITUAL_HELP = `
+Ritual cadence:
+  bisque drift is a MANUAL, ritual-cadence command \u2014 run it like /bisque:distill
+  (e.g. at the start of a sync session), NEVER per-session or per-tool-call. It
+  is deliberately NOT wired into any SessionStart / PostToolUse hook. It only
+  TRIAGES which project context docs may have drifted from code; it never
+  archives, rejects, or "fixes" anything \u2014 the agent reconcile ritual decides.
+
+Signals (mechanical, no LLM):
+  link-rot      a referenced codePath no longer exists at HEAD
+  breaking      an in-window feat!/fix!/BREAKING CHANGE commit touched a ref
+  time-decay    PARA-bucketed cadence timer over the doc's last update
+
+Examples:
+  bisque drift --project BisqueLayer
+  bisque drift --project BisqueLayer --json
+  bisque drift --project BisqueLayer --experimental-churn
+`;
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function resolveProjectPrefix(input) {
+  if (!input) return "1-Projects/";
+  let name = input.trim();
+  if (name.startsWith("1-Projects/")) name = name.slice("1-Projects/".length);
+  name = name.replace(/^\/+/, "").replace(/\/+$/, "");
+  return name ? `1-Projects/${name}/` : "1-Projects/";
+}
+function resolveWatermark(docs) {
+  const statusDocs = docs.filter((d) => d.filepath.toLowerCase().endsWith("frontmind/status.md"));
+  const withWm = statusDocs.filter((d) => asString(d.metadata?.["codeWatermark"]));
+  if (withWm.length === 1) {
+    const d = withWm[0];
+    return {
+      watermarkSha: asString(d.metadata?.["codeWatermark"]) ?? null,
+      lastDistilledAt: asString(d.metadata?.["lastDistilledAt"]) ?? null,
+      ambiguous: false
+    };
+  }
+  if (withWm.length > 1) return { watermarkSha: null, lastDistilledAt: null, ambiguous: true };
+  const single = statusDocs.length === 1 ? statusDocs[0] : void 0;
+  return {
+    watermarkSha: null,
+    lastDistilledAt: single ? asString(single.metadata?.["lastDistilledAt"]) ?? null : null,
+    ambiguous: false
+  };
+}
+function derivePathspec(allCodePaths) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const p of allCodePaths) {
+    const slash = p.lastIndexOf("/");
+    dirs.add(slash >= 0 ? p.slice(0, slash) : p);
+  }
+  return [...dirs];
+}
+async function readBisqueignore(cwd) {
+  try {
+    return await readFile4(`${cwd}/.bisqueignore`, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function signalColor(signal) {
+  if (signal === "breaking") return chalk3.red(signal);
+  if (signal === "link-rot") return chalk3.yellow(signal);
+  return chalk3.gray(signal);
+}
+function renderBanner(prefix, git, watermark) {
+  console.log(chalk3.bold.cyan(`
+Drift triage \u2014 ${prefix}`));
+  const since = git.watermarkSha ? git.watermarkSha.slice(0, 7) : null;
+  const head = git.headShaShort || "(unknown)";
+  if (since) {
+    console.log(chalk3.gray(`  Window: ${since}..${head} (committer-date UTC)`));
+  } else {
+    console.log(chalk3.gray(`  Window: first-run bounded (no codeWatermark) \u2192 up to HEAD ${head}`));
+  }
+  if (watermark.ambiguous) {
+    console.log(
+      chalk3.yellow(
+        "  Note: multiple projects with watermarks in scope \u2014 using first-run window. Pass --project to scope."
+      )
+    );
+  }
+  if (git.watermarkFellBack) {
+    console.log(
+      chalk3.yellow(
+        "  Note: codeWatermark no longer resolves in git \u2192 fell back to first-run window."
+      )
+    );
+  }
+  console.log(chalk3.gray(`  Last distilled: ${watermark.lastDistilledAt ?? "(never)"}`));
+}
+function renderTable(scored, churnEnabled) {
+  const flagged = scored.filter((d) => d.score > 0);
+  if (flagged.length === 0) {
+    console.log(chalk3.green("\nNo drift signals. Context looks in sync with code."));
+    return;
+  }
+  const head = [
+    chalk3.cyan("#"),
+    chalk3.cyan("Signal"),
+    chalk3.cyan("Score"),
+    chalk3.cyan("Prov"),
+    chalk3.cyan("Evidence"),
+    chalk3.cyan("Filepath")
+  ];
+  if (churnEnabled) head.splice(5, 0, chalk3.cyan("Churn*"));
+  const table = new Table2({ head, style: { head: [], border: ["gray"] } });
+  flagged.forEach((d, i) => {
+    const row = [
+      String(i + 1),
+      signalColor(d.signal),
+      d.score.toFixed(2),
+      d.hasProvenance ? "yes" : chalk3.gray("no"),
+      d.evidence.slice(0, 3).join("\n") || chalk3.gray("\u2014"),
+      d.filepath
+    ];
+    if (churnEnabled) row.splice(5, 0, d.churn >= 0 ? String(d.churn) : chalk3.gray("\u2014"));
+    table.push(row);
+  });
+  console.log(`
+${table.toString()}`);
+  if (churnEnabled) {
+    console.log(
+      chalk3.gray(
+        "\n  * Churn is EXPERIMENTAL (doc-class-gated, dated records excluded) and is NOT a ranker."
+      )
+    );
+  }
+}
+function renderUncovered(uncovered) {
+  if (uncovered.files.length === 0 && uncovered.more === 0) return;
+  console.log(chalk3.bold("\nNew code lacking context (added in-window, no doc references it):"));
+  for (const f of uncovered.files) console.log(chalk3.gray(`  + ${f}`));
+  if (uncovered.more > 0) console.log(chalk3.gray(`  + ${uncovered.more} more`));
+}
+async function runDrift(options) {
+  const prefix = resolveProjectPrefix(options.project);
+  const client = new ApiClient();
+  const docs = await fetchAllDocumentsMetadata(client, {
+    pathPrefix: prefix,
+    ...options.workspace ? { workspace: options.workspace } : {}
+  });
+  if (docs.length === 0) {
+    console.log(chalk3.yellow(`No documents found under ${prefix}`));
+    return;
+  }
+  const watermark = resolveWatermark(docs);
+  const scorable = docs;
+  const allCodePaths = /* @__PURE__ */ new Set();
+  for (const d of docs) for (const p of getCodePaths(d)) allCodePaths.add(p);
+  const git = await loadGitContext({
+    cwd: process.cwd(),
+    watermarkSha: watermark.watermarkSha,
+    pathspec: derivePathspec([...allCodePaths]),
+    maxCommits: Number.parseInt(options.maxCommits, 10) || void 0
+  });
+  if (!git.isRepo) {
+    console.error(
+      "Error: not a git repository (run bisque drift from inside the project's repo \u2014 drift compares docs against the local code)."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const ignoreContent = await readBisqueignore(process.cwd());
+  const isIgnored = createIgnoreMatcher(ignoreContent);
+  const nowMs = Date.now();
+  const scored = scoreAndRank(scorable, {
+    headFiles: git.headFiles,
+    breakingTouched: git.breakingTouchedPaths,
+    nowMs,
+    numstatByPath: git.numstatByPath,
+    churnEnabled: options.experimentalChurn === true
+  });
+  const uncovered = buildUncoveredHint(git.addedPaths, allCodePaths, isIgnored);
+  if (options.json) {
+    const digest = buildDigest(scored, {
+      project: prefix,
+      generatedAt: new Date(nowMs).toISOString(),
+      watermarkSince: git.watermarkSha ? git.watermarkSha.slice(0, 7) : null,
+      headShort: git.headShaShort,
+      lastDistilledAt: watermark.lastDistilledAt,
+      uncovered
+    });
+    const out = JSON.stringify(digest);
+    console.log(out);
+    recordMeasurement(
+      "drift",
+      { projectPath: prefix, workspaceId: options.workspace, json: true },
+      out.length
+    );
+    return;
+  }
+  renderBanner(prefix, git, watermark);
+  renderTable(scored, options.experimentalChurn === true);
+  renderUncovered(uncovered);
+  const forced = scored.filter((d) => d.linkRot || d.breaking).length;
+  console.log(
+    chalk3.gray(
+      `
+${scored.length} doc(s) scored \xB7 ${forced} forced by link-rot/breaking \xB7 triage only (the agent reconcile ritual decides).`
+    )
+  );
+  recordMeasurement(
+    "drift",
+    { projectPath: prefix, workspaceId: options.workspace, json: false },
+    scored.length
+  );
+}
+function registerDriftCommand(program2) {
+  program2.command("drift").description(
+    "Triage which project context docs may have drifted from code (mechanical, no-LLM). Ritual cadence \u2014 run like /distill, never per-session."
+  ).option(
+    "--project <path>",
+    'Project to scope to: a name ("BisqueLayer") or PARA path ("1-Projects/BisqueLayer"). Defaults to all 1-Projects/.'
+  ).option("--workspace <id>", "Workspace ID").option("--json", "Emit a compact \u22642K-token top-K(25) triage digest as JSON").option(
+    "--experimental-churn",
+    "Add an EXPERIMENTAL churn-magnitude column (doc-class-gated; NOT a ranker)"
+  ).option(
+    "--max-commits <n>",
+    "First-run window bound (commits) when no codeWatermark exists",
+    "200"
+  ).addHelpText("after", RITUAL_HELP).action(async (options) => {
+    try {
+      await runDrift(options);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/commands/get.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { Option } from "commander";
 init_api_client();
 function registerGetCommand(program2) {
   program2.command("get <docId>").description("Retrieve a document by ID").option("-o, --output <file>", "Save content to a file instead of stdout").addOption(
@@ -2522,65 +3527,97 @@ function registerLinkCommand(program2) {
 }
 
 // src/commands/list.ts
-import chalk3 from "chalk";
-import Table2 from "cli-table3";
+import chalk4 from "chalk";
+import Table3 from "cli-table3";
 init_api_client();
-function registerListCommand(program2) {
-  program2.command("list").description("List documents with optional filters").option("--path-prefix <prefix>", "Filter by path prefix").option("--filepath <path>", "Filter by exact filepath").option("--workspace <id>", "Workspace ID").option("--limit <n>", "Max results", "20").action(
-    async (options) => {
-      try {
-        const params = new URLSearchParams();
-        params.set("limit", options.limit);
-        if (options.pathPrefix) {
-          params.set("pathPrefix", options.pathPrefix);
-        }
-        if (options.filepath) {
-          params.set("filepath", options.filepath);
-        }
-        if (options.workspace) {
-          params.set("workspace", options.workspace);
-        }
-        const client = new ApiClient();
-        const response = await client.get(
-          `/v1/documents?${params.toString()}`
-        );
-        const docs = response.items ?? [];
-        recordMeasurement(
-          "list",
-          {
-            pathPrefix: options.pathPrefix,
-            filepath: options.filepath,
-            workspaceId: options.workspace,
-            limit: options.limit
-          },
-          JSON.stringify(docs).length
-        );
-        if (docs.length === 0) {
-          console.log(chalk3.yellow("No documents found."));
-          return;
-        }
-        const table = new Table2({
-          head: [chalk3.cyan("Title"), chalk3.cyan("Filepath"), chalk3.cyan("Document ID")],
-          style: { head: [], border: ["gray"] }
-        });
-        for (const doc of docs) {
-          table.push([doc.title, doc.filepath, doc.documentId]);
-        }
-        console.log(table.toString());
-        console.log(chalk3.gray(`
+function renderTable2(docs) {
+  const table = new Table3({
+    head: [chalk4.cyan("Title"), chalk4.cyan("Filepath"), chalk4.cyan("Document ID")],
+    style: { head: [], border: ["gray"] }
+  });
+  for (const doc of docs) {
+    table.push([doc.title, doc.filepath, doc.documentId]);
+  }
+  console.log(table.toString());
+  console.log(chalk4.gray(`
 Total: ${docs.length} document(s)`));
-        if (response.cursor) {
-          console.log(chalk3.gray("More results available \u2014 re-run with a larger --limit."));
-        }
-      } catch (error) {
-        exitWithError(error);
+}
+async function runMetadataList(options) {
+  const client = new ApiClient();
+  const pageLimit = Number.parseInt(options.limit, 10);
+  const docs = await fetchAllDocumentsMetadata(client, {
+    ...options.pathPrefix ? { pathPrefix: options.pathPrefix } : {},
+    ...options.workspace ? { workspace: options.workspace } : {},
+    ...Number.isFinite(pageLimit) && pageLimit > 0 ? { pageLimit } : {}
+  });
+  recordMeasurement(
+    "list",
+    {
+      pathPrefix: options.pathPrefix,
+      workspaceId: options.workspace,
+      limit: options.limit,
+      view: "metadata"
+    },
+    JSON.stringify(docs).length
+  );
+  if (docs.length === 0) {
+    console.log(chalk4.yellow("No documents found."));
+    return;
+  }
+  renderTable2(docs);
+}
+function registerListCommand(program2) {
+  program2.command("list").description("List documents with optional filters").option("--path-prefix <prefix>", "Filter by path prefix").option("--filepath <path>", "Filter by exact filepath").option("--workspace <id>", "Workspace ID").option("--limit <n>", "Max results", "20").option(
+    "--view <mode>",
+    "Projection mode: 'metadata' omits content and follows the cursor to enumerate ALL matching docs"
+  ).action(async (options) => {
+    try {
+      if (options.view === "metadata") {
+        await runMetadataList(options);
+        return;
+      }
+      const params = new URLSearchParams();
+      params.set("limit", options.limit);
+      if (options.pathPrefix) {
+        params.set("pathPrefix", options.pathPrefix);
+      }
+      if (options.filepath) {
+        params.set("filepath", options.filepath);
+      }
+      if (options.workspace) {
+        params.set("workspace", options.workspace);
+      }
+      const client = new ApiClient();
+      const response = await client.get(
+        `/v1/documents?${params.toString()}`
+      );
+      const docs = response.items ?? [];
+      recordMeasurement(
+        "list",
+        {
+          pathPrefix: options.pathPrefix,
+          filepath: options.filepath,
+          workspaceId: options.workspace,
+          limit: options.limit
+        },
+        JSON.stringify(docs).length
+      );
+      if (docs.length === 0) {
+        console.log(chalk4.yellow("No documents found."));
+        return;
+      }
+      renderTable2(docs);
+      if (response.cursor) {
+        console.log(chalk4.gray("More results available \u2014 re-run with a larger --limit."));
       }
+    } catch (error) {
+      exitWithError(error);
     }
-  );
+  });
 }
 
 // src/commands/load.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 init_api_client();
 function normalize(s) {
   return s.toLowerCase().replace(/[-_\s]/g, "");
@@ -2623,8 +3660,8 @@ function registerLoadCommand(program2) {
             )
           );
         } else {
-          console.error(chalk4.red(`Project not found: "${project}"`));
-          console.log(chalk4.yellow(`Available projects: ${projectNames.join(", ") || "(none)"}`));
+          console.error(chalk5.red(`Project not found: "${project}"`));
+          console.log(chalk5.yellow(`Available projects: ${projectNames.join(", ") || "(none)"}`));
         }
         process.exitCode = 1;
         return;
@@ -2675,35 +3712,35 @@ function registerLoadCommand(program2) {
         );
         return;
       }
-      console.log(chalk4.bold.cyan(`
+      console.log(chalk5.bold.cyan(`
 === ${matchedName} ===
 `));
       if (agentsMd) {
-        console.log(chalk4.bold("AGENTS.md:"));
+        console.log(chalk5.bold("AGENTS.md:"));
         console.log(agentsMd.content);
         console.log();
       } else {
-        console.log(chalk4.yellow("No AGENTS.md found for this project.\n"));
+        console.log(chalk5.yellow("No AGENTS.md found for this project.\n"));
       }
       if (frontmind.length > 0) {
-        console.log(chalk4.bold(`Frontmind (${frontmind.length} files):`));
+        console.log(chalk5.bold(`Frontmind (${frontmind.length} files):`));
         for (const doc of frontmind) {
-          console.log(chalk4.cyan(`
+          console.log(chalk5.cyan(`
 --- ${doc.filepath} ---`));
           console.log(doc.content);
         }
         console.log();
       } else {
-        console.log(chalk4.gray("No frontmind files.\n"));
+        console.log(chalk5.gray("No frontmind files.\n"));
       }
       if (backmind.length > 0) {
-        console.log(chalk4.bold(`Backmind (${backmind.length} files available):`));
+        console.log(chalk5.bold(`Backmind (${backmind.length} files available):`));
         for (const entry of backmind) {
-          console.log(chalk4.gray(`  ${entry.filepath} \u2014 ${entry.title}`));
+          console.log(chalk5.gray(`  ${entry.filepath} \u2014 ${entry.title}`));
         }
-        console.log(chalk4.gray("\n  Use: bisque get <documentId> to load any backmind file."));
+        console.log(chalk5.gray("\n  Use: bisque get <documentId> to load any backmind file."));
       } else {
-        console.log(chalk4.gray("No backmind files."));
+        console.log(chalk5.gray("No backmind files."));
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -2715,14 +3752,14 @@ function registerLoadCommand(program2) {
 
 // src/commands/ls.ts
 init_api_client();
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 function formatFolder(entry) {
   const countInfo = entry.childCount != null ? `(${entry.childCount} files)` : entry.hasChildren ? "(has children)" : "";
-  return `  ${chalk5.blue(`${entry.name}/`)}  ${chalk5.dim(countInfo)}`;
+  return `  ${chalk6.blue(`${entry.name}/`)}  ${chalk6.dim(countInfo)}`;
 }
 function formatFile(entry) {
   const date = entry.updatedAt ? new Date(entry.updatedAt).toISOString().split("T")[0] : "";
-  return `  ${entry.name}  ${chalk5.dim(`"${entry.title}"`)}  ${chalk5.dim(date)}`;
+  return `  ${entry.name}  ${chalk6.dim(`"${entry.title}"`)}  ${chalk6.dim(date)}`;
 }
 function buildParams(path2, options) {
   const params = new URLSearchParams();
@@ -2749,7 +3786,7 @@ function registerLsCommand(program2) {
       }
       const data = result;
       if (!data.entries || data.entries.length === 0) {
-        console.log(chalk5.dim("  (empty)"));
+        console.log(chalk6.dim("  (empty)"));
         return;
       }
       displayEntries(data.entries);
@@ -2761,15 +3798,15 @@ function registerLsCommand(program2) {
 
 // src/commands/maintenance.ts
 init_api_client();
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 function healthColor(health) {
   switch (health) {
     case "healthy":
-      return chalk6.green(health);
+      return chalk7.green(health);
     case "needs-attention":
-      return chalk6.yellow(health);
+      return chalk7.yellow(health);
     case "needs-maintenance":
-      return chalk6.red(health);
+      return chalk7.red(health);
     default:
       return health;
   }
@@ -2782,7 +3819,7 @@ function scopeLabel(scope) {
 }
 function printRecommendationLine(label, count) {
   if (count > 0) {
-    console.log(`  ${chalk6.yellow("*")} ${label}: ${count}`);
+    console.log(`  ${chalk7.yellow("*")} ${label}: ${count}`);
   }
 }
 function registerMaintenanceCommand(program2) {
@@ -2801,26 +3838,26 @@ function registerMaintenanceCommand(program2) {
       }
       const report = await client.post("/v1/maintenance", body);
       console.log();
-      console.log(chalk6.bold("Workspace Maintenance Report"));
+      console.log(chalk7.bold("Workspace Maintenance Report"));
       console.log(`Scope: ${scopeLabel(report.scope)}  |  ${report.timestamp}`);
       console.log();
       const { mechanical } = report;
       const hasMechanical = mechanical.taskLocksReleased.length > 0 || mechanical.chainsCompleted.length > 0 || mechanical.errors.length > 0;
       if (hasMechanical) {
-        console.log(chalk6.bold("Mechanical Fixes"));
+        console.log(chalk7.bold("Mechanical Fixes"));
         for (const lock of mechanical.taskLocksReleased) {
           console.log(
-            `  ${chalk6.green("\u2713")} Released expired lock: ${lock.title} (${lock.taskId.substring(0, 8)})`
+            `  ${chalk7.green("\u2713")} Released expired lock: ${lock.title} (${lock.taskId.substring(0, 8)})`
           );
         }
         for (const chain of mechanical.chainsCompleted) {
           console.log(
-            `  ${chalk6.green("\u2713")} Completed chain: ${chain.name} (${chain.chainId.substring(0, 8)})`
+            `  ${chalk7.green("\u2713")} Completed chain: ${chain.name} (${chain.chainId.substring(0, 8)})`
           );
         }
         for (const err of mechanical.errors) {
           console.log(
-            `  ${chalk6.red("\u2717")} ${err.operation} failed on ${err.entityId.substring(0, 8)}: ${err.error}`
+            `  ${chalk7.red("\u2717")} ${err.operation} failed on ${err.entityId.substring(0, 8)}: ${err.error}`
           );
         }
         console.log();
@@ -2828,7 +3865,7 @@ function registerMaintenanceCommand(program2) {
       const { recommendations: rec } = report;
       const hasRecommendations = report.summary.recommendations > 0;
       if (hasRecommendations) {
-        console.log(chalk6.bold("Recommendations"));
+        console.log(chalk7.bold("Recommendations"));
         printRecommendationLine("Inbox items pending triage", rec.inboxItems.length);
         printRecommendationLine("Stale documents", rec.staleDocs.length);
         printRecommendationLine("AGENTS.md refresh needed", rec.agentsMdRefreshNeeded.length);
@@ -2844,7 +3881,7 @@ function registerMaintenanceCommand(program2) {
         printRecommendationLine("Misplaced documents", rec.misplacedDocs.length);
         console.log();
       }
-      console.log(chalk6.bold("Summary"));
+      console.log(chalk7.bold("Summary"));
       console.log(`  Mechanical fixes: ${report.summary.mechanicalFixes}`);
       console.log(`  Recommendations:  ${report.summary.recommendations}`);
       console.log(`  Health:           ${healthColor(report.summary.workspaceHealth)}`);
@@ -2965,7 +4002,7 @@ function renderReferenceTable(stats) {
   );
   return [header, sep, ...body].join("\n");
 }
-function renderTable(stats) {
+function renderTable3(stats) {
   const header = "| command | n calls | avg tokens | p50 | p95 | total tokens |";
   const sep = "|---|---|---|---|---|---|";
   const body = stats.map(
@@ -3007,7 +4044,7 @@ function runSummarize(opts) {
     console.log("No measurements match your filters.");
     return;
   }
-  console.log(renderTable(stats));
+  console.log(renderTable3(stats));
 }
 function registerMeasureCommand(program2) {
   const measure = program2.command("measure").description("Inspect measurement data captured by BISQUE_MEASURE=1");
@@ -3059,8 +4096,8 @@ function registerMoveCommand(program2) {
 // src/commands/persona.ts
 init_api_client();
 import { createInterface as createInterface2 } from "node:readline";
-import chalk7 from "chalk";
-import Table3 from "cli-table3";
+import chalk8 from "chalk";
+import Table4 from "cli-table3";
 function confirm2(prompt) {
   const rl = createInterface2({
     input: process.stdin,
@@ -3084,16 +4121,16 @@ function registerPersonaCommand(program2) {
         return;
       }
       if (data.agentPersonas.length === 0) {
-        console.log(chalk7.yellow("No personas found."));
+        console.log(chalk8.yellow("No personas found."));
         return;
       }
-      const table = new Table3({
+      const table = new Table4({
         head: [
-          chalk7.cyan("ID"),
-          chalk7.cyan("Name"),
-          chalk7.cyan("Specialization"),
-          chalk7.cyan("Tasks"),
-          chalk7.cyan("Last Active")
+          chalk8.cyan("ID"),
+          chalk8.cyan("Name"),
+          chalk8.cyan("Specialization"),
+          chalk8.cyan("Tasks"),
+          chalk8.cyan("Last Active")
         ],
         style: {
           head: [],
@@ -3111,7 +4148,7 @@ function registerPersonaCommand(program2) {
         ]);
       }
       console.log(table.toString());
-      console.log(chalk7.gray(`
+      console.log(chalk8.gray(`
 Total: ${data.agentPersonas.length} persona(s)`));
     } catch (error) {
       exitWithError(error);
@@ -3132,13 +4169,13 @@ Total: ${data.agentPersonas.length} persona(s)`));
       console.log(`Created:        ${p.createdAt}`);
       console.log(`Updated:        ${p.updatedAt}`);
       if (p.learnings && p.learnings.length > 0) {
-        console.log(chalk7.cyan("\nLearnings:"));
+        console.log(chalk8.cyan("\nLearnings:"));
         for (const l of p.learnings) {
           console.log(`  - ${l}`);
         }
       }
       if (p.feedback && p.feedback.length > 0) {
-        console.log(chalk7.cyan("\nFeedback:"));
+        console.log(chalk8.cyan("\nFeedback:"));
         for (const f of p.feedback) {
           console.log(`  - ${f}`);
         }
@@ -3229,7 +4266,7 @@ Total: ${data.agentPersonas.length} persona(s)`));
 
 // src/commands/plugin.ts
 import { spawn } from "node:child_process";
-var BISQUE_MARKETPLACE_SOURCE = "Kokonaut/bisque";
+var BISQUE_MARKETPLACE_SOURCE = "Kokonaut/bisque-marketplace";
 var BISQUE_MARKETPLACE_NAME = "bisque-marketplace";
 var BISQUE_PLUGIN_NAME = "bisque";
 var BISQUE_PLUGIN_QUALIFIED = `${BISQUE_PLUGIN_NAME}@${BISQUE_MARKETPLACE_NAME}`;
@@ -3694,8 +4731,8 @@ function registerTagCommand(program2) {
 // src/commands/task.ts
 init_api_client();
 import { createInterface as createInterface3 } from "node:readline";
-import chalk8 from "chalk";
-import Table4 from "cli-table3";
+import chalk9 from "chalk";
+import Table5 from "cli-table3";
 import { Option as Option2 } from "commander";
 var PICKUP_MODES = ["interactive", "autonomous"];
 function splitCsv(value) {
@@ -3771,16 +4808,16 @@ function registerTaskCommand(program2) {
         const path2 = query ? `/v1/tasks?${query}` : "/v1/tasks";
         const data = await client.get(path2);
         if (data.length === 0) {
-          console.log(chalk8.yellow("No tasks found."));
+          console.log(chalk9.yellow("No tasks found."));
           return;
         }
-        const table = new Table4({
+        const table = new Table5({
           head: [
-            chalk8.cyan("#"),
-            chalk8.cyan("Title"),
-            chalk8.cyan("Status"),
-            chalk8.cyan("ID"),
-            chalk8.cyan("Chain")
+            chalk9.cyan("#"),
+            chalk9.cyan("Title"),
+            chalk9.cyan("Status"),
+            chalk9.cyan("ID"),
+            chalk9.cyan("Chain")
           ],
           style: {
             head: [],
@@ -3793,7 +4830,7 @@ function registerTaskCommand(program2) {
           table.push([num, title, item.status, item.documentId, item.chainId ?? "-"]);
         }
         console.log(table.toString());
-        console.log(chalk8.gray(`
+        console.log(chalk9.gray(`
 Total: ${data.length} task(s)`));
       } catch (error) {
         exitWithError(error);
@@ -3916,7 +4953,7 @@ Total: ${data.length} task(s)`));
 
 // src/commands/tree.ts
 init_api_client();
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 function registerTreeCommand(program2) {
   program2.command("tree [path]").description(
     "Recursively fetch documents with content. WARNING: This is the most expensive navigation operation. Prefer 'bisque ls' for navigation and 'bisque batch' for targeted loading."
@@ -3936,19 +4973,19 @@ function registerTreeCommand(program2) {
         }
         const data = result;
         if (!data.documents || data.documents.length === 0) {
-          console.log(chalk9.dim("  (empty)"));
+          console.log(chalk10.dim("  (empty)"));
           return;
         }
         for (const doc of data.documents) {
-          console.log(chalk9.blue(`--- ${doc.filepath} ---`));
-          console.log(chalk9.dim(`Title: ${doc.title}`));
+          console.log(chalk10.blue(`--- ${doc.filepath} ---`));
+          console.log(chalk10.dim(`Title: ${doc.title}`));
           console.log(doc.content);
           console.log();
         }
-        console.log(chalk9.dim(`Returned ${data.totalReturned}/${data.maxItems} max items`));
+        console.log(chalk10.dim(`Returned ${data.totalReturned}/${data.maxItems} max items`));
         if (data.cursor) {
           console.log(
-            chalk9.yellow("More results available. Use --json to get cursor for pagination.")
+            chalk10.yellow("More results available. Use --json to get cursor for pagination.")
           );
         }
       } catch (err) {
@@ -3960,6 +4997,9 @@ function registerTreeCommand(program2) {
 
 // src/commands/update.ts
 init_api_client();
+function parseCommaList(val) {
+  return val.split(",").map((s) => s.trim()).filter(Boolean);
+}
 function parseMetadataJson2(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -3998,9 +5038,20 @@ function buildUpdateBody(options) {
   if (options.status !== void 0) {
     body["status"] = options.status;
   }
+  const codePaths = resolveCodePaths(
+    options.codePaths,
+    body["metadata"],
+    options.content ?? ""
+  );
+  if (codePaths) {
+    body["metadata"] = {
+      ...body["metadata"] ?? {},
+      codePaths
+    };
+  }
   if (Object.keys(body).length === 0) {
     return {
-      error: "Error: at least one update flag is required (--title, --content, --summary, --tags, --keywords, --metadata, --status)"
+      error: "Error: at least one update flag is required (--title, --content, --summary, --tags, --keywords, --metadata, --code-paths, --status)"
     };
   }
   return { body };
@@ -4010,6 +5061,10 @@ function registerUpdateCommand(program2) {
     "--summary <summary>",
     "Set the doc's summary field (short abstract, rendered in AGENTS.md ## What's here)"
   ).option("--tags <tags>", "Replace tags (comma-separated)").option("--keywords <keywords>", "Replace keywords (comma-separated)").option("--metadata <json>", "JSON metadata object").option(
+    "--code-paths <paths>",
+    "Comma-separated source paths this doc describes (overrides auto-extraction)",
+    parseCommaList
+  ).option(
     "--status <status>",
     "New lifecycle state: live | superseded | archived. Used for manual transitions (e.g. archiving a draft). Supersession-specific transitions go through the v1.5 supersession route."
   ).action(async (docId, options) => {
@@ -4034,8 +5089,8 @@ init_src();
 init_config();
 init_api_client();
 import { createInterface as createInterface4 } from "node:readline/promises";
-import chalk10 from "chalk";
-import Table5 from "cli-table3";
+import chalk11 from "chalk";
+import Table6 from "cli-table3";
 init_runtime_context();
 init_workspace_context();
 async function resolveSubcommandWorkspaceId(options, config) {
@@ -4078,21 +5133,21 @@ async function workspaceList(json) {
       return;
     }
     if (cache.workspaces.length === 0) {
-      console.log(chalk10.yellow("No workspaces found."));
+      console.log(chalk11.yellow("No workspaces found."));
       return;
     }
     const personal = cache.workspaces.filter((w) => w.isPersonal);
     const shared = cache.workspaces.filter((w) => !w.isPersonal);
     const renderSection2 = (label, items) => {
       if (items.length === 0) return;
-      console.log(chalk10.bold.cyan(`
+      console.log(chalk11.bold.cyan(`
 ${label}`));
-      const table = new Table5({
+      const table = new Table6({
         head: [
-          chalk10.cyan("ID"),
-          chalk10.cyan("Name"),
-          chalk10.cyan("Role"),
-          chalk10.cyan("Last accessed")
+          chalk11.cyan("ID"),
+          chalk11.cyan("Name"),
+          chalk11.cyan("Role"),
+          chalk11.cyan("Last accessed")
         ],
         style: { head: [], border: ["gray"] }
       });
@@ -4104,7 +5159,7 @@ ${label}`));
     };
     renderSection2("Personal", personal);
     renderSection2("Shared", shared);
-    console.log(chalk10.gray(`
+    console.log(chalk11.gray(`
 Total: ${cache.workspaces.length} workspace(s)`));
   } catch (error) {
     exitWithError(error);
@@ -4116,18 +5171,18 @@ async function workspaceSwitch(id) {
     const cache = await refreshWorkspacesCache(config);
     const match = cache.workspaces.find((w) => w.workspaceId === id);
     if (!match) {
-      console.error(chalk10.red(`Error: workspace '${id}' not found among your memberships.`));
+      console.error(chalk11.red(`Error: workspace '${id}' not found among your memberships.`));
       console.error(
-        chalk10.gray(
+        chalk11.gray(
           "Run `bisque workspace list` to see what you can access. To join a workspace, run `bisque workspace join <code>`."
         )
       );
       process.exit(3);
     }
     await config.set("activeWorkspaceId", id);
-    console.log(chalk10.green(`Active workspace set: ${match.name} (${match.role})`));
+    console.log(chalk11.green(`Active workspace set: ${match.name} (${match.role})`));
     console.log(
-      chalk10.yellow(
+      chalk11.yellow(
         "Note: Agents must still pass `--workspace <id>` explicitly on every mutating operation. This setting is a human convenience and is NOT read by agents."
       )
     );
@@ -4144,17 +5199,17 @@ async function workspaceCreate(name, options) {
       console.log(JSON.stringify(ws, null, 2));
       return;
     }
-    console.log(chalk10.green(`Workspace created: ${ws.name}`));
+    console.log(chalk11.green(`Workspace created: ${ws.name}`));
     console.log(`  ID: ${ws.workspaceId}`);
     console.log(`  Owner: ${ws.ownerUserId}`);
     const yes = options.yes === true || await confirm4("Switch to this workspace now? [y/N]", false);
     if (yes) {
       await refreshWorkspacesCache(config);
       await config.set("activeWorkspaceId", ws.workspaceId);
-      console.log(chalk10.green(`Active workspace set: ${ws.name} (owner)`));
+      console.log(chalk11.green(`Active workspace set: ${ws.name} (owner)`));
     } else {
       console.log(
-        chalk10.gray(
+        chalk11.gray(
           `Workspace ready. Run \`bisque workspace switch ${ws.workspaceId}\` to make it active.`
         )
       );
@@ -4169,7 +5224,7 @@ async function workspaceInvite(options) {
     const targetWs = await resolveSubcommandWorkspaceId(options, config);
     if (!targetWs) {
       console.error(
-        chalk10.red(
+        chalk11.red(
           "Error: no active workspace. Use --workspace <id> or run `bisque workspace switch`."
         )
       );
@@ -4177,20 +5232,20 @@ async function workspaceInvite(options) {
     }
     const maxRedemptions = options.maxUses ? Number(options.maxUses) : 1;
     if (!Number.isInteger(maxRedemptions) || maxRedemptions < 1 || maxRedemptions > 100) {
-      console.error(chalk10.red("Error: --max-uses must be an integer between 1 and 100."));
+      console.error(chalk11.red("Error: --max-uses must be an integer between 1 and 100."));
       process.exit(1);
     }
     const expiresIn = options.expires ?? "7d";
     const expiresAt = parseExpiresAt(expiresIn);
     if (expiresAt === void 0) {
       console.error(
-        chalk10.red("Error: --expires must be a duration like '7d', '24h', '30m' (max 30d).")
+        chalk11.red("Error: --expires must be a duration like '7d', '24h', '30m' (max 30d).")
       );
       process.exit(1);
     }
     const maxExpiresAt = Math.floor(Date.now() / 1e3) + 30 * 86400;
     if (expiresAt > maxExpiresAt) {
-      console.error(chalk10.red("Error: --expires must not exceed 30 days."));
+      console.error(chalk11.red("Error: --expires must not exceed 30 days."));
       process.exit(1);
     }
     const body = {
@@ -4208,13 +5263,13 @@ async function workspaceInvite(options) {
       return;
     }
     const expiresHuman = new Date(created.expiresAt * 1e3).toLocaleString();
-    console.log(chalk10.green(`Invite code created: ${chalk10.bold(created.code)}`));
+    console.log(chalk11.green(`Invite code created: ${chalk11.bold(created.code)}`));
     console.log(`  Role: ${created.roleOnRedeem}`);
     console.log(`  Max uses: ${created.maxRedemptions}`);
     console.log(`  Expires: ${expiresHuman}`);
     console.log("");
-    console.log(chalk10.gray("Share with your teammate:"));
-    console.log(chalk10.bold(`  bisque workspace join ${created.code}`));
+    console.log(chalk11.gray("Share with your teammate:"));
+    console.log(chalk11.bold(`  bisque workspace join ${created.code}`));
   } catch (error) {
     exitWithError(error);
   }
@@ -4230,11 +5285,11 @@ async function workspaceJoin(code, options) {
       return;
     }
     const verb = result.idempotent ? "Already a member of" : "Joined";
-    console.log(chalk10.green(`${verb} workspace: ${result.workspaceId} (role: ${result.role})`));
+    console.log(chalk11.green(`${verb} workspace: ${result.workspaceId} (role: ${result.role})`));
     const yes = options.yes === true || await confirm4("Switch to this workspace now? [y/N]", false);
     if (yes) {
       await config.set("activeWorkspaceId", result.workspaceId);
-      console.log(chalk10.green("Active workspace updated."));
+      console.log(chalk11.green("Active workspace updated."));
     }
   } catch (error) {
     exitWithError(error);
@@ -4246,7 +5301,7 @@ async function workspaceMembers(options) {
     const targetWs = await resolveSubcommandWorkspaceId(options, config);
     if (!targetWs) {
       console.error(
-        chalk10.red(
+        chalk11.red(
           "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
         )
       );
@@ -4260,15 +5315,15 @@ async function workspaceMembers(options) {
       return;
     }
     if (members.length === 0) {
-      console.log(chalk10.yellow("No members found."));
+      console.log(chalk11.yellow("No members found."));
       return;
     }
-    const table = new Table5({
+    const table = new Table6({
       head: [
-        chalk10.cyan("User ID"),
-        chalk10.cyan("Role"),
-        chalk10.cyan("Joined"),
-        chalk10.cyan("Last accessed")
+        chalk11.cyan("User ID"),
+        chalk11.cyan("Role"),
+        chalk11.cyan("Joined"),
+        chalk11.cyan("Last accessed")
       ],
       style: { head: [], border: ["gray"] }
     });
@@ -4278,7 +5333,7 @@ async function workspaceMembers(options) {
       table.push([m.userId, m.role, joined, last]);
     }
     console.log(table.toString());
-    console.log(chalk10.gray(`
+    console.log(chalk11.gray(`
 Total: ${members.length} member(s)`));
   } catch (error) {
     exitWithError(error);
@@ -4290,7 +5345,7 @@ async function workspaceTransfer(targetUserId, options) {
     const targetWs = await resolveSubcommandWorkspaceId(options, config);
     if (!targetWs) {
       console.error(
-        chalk10.red(
+        chalk11.red(
           "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
         )
       );
@@ -4306,7 +5361,7 @@ async function workspaceTransfer(targetUserId, options) {
         console.log(JSON.stringify(result2, null, 2));
         return;
       }
-      console.log(chalk10.green(`Successor cleared for workspace ${result2.name}.`));
+      console.log(chalk11.green(`Successor cleared for workspace ${result2.name}.`));
       return;
     }
     const result = await client.post(`/v1/workspaces/${targetWs}/ownership-transfer`, {
@@ -4318,7 +5373,7 @@ async function workspaceTransfer(targetUserId, options) {
       return;
     }
     console.log(
-      chalk10.green(`Ownership transferred to ${targetUserId} for workspace ${result.name}.`)
+      chalk11.green(`Ownership transferred to ${targetUserId} for workspace ${result.name}.`)
     );
   } catch (error) {
     exitWithError(error);
@@ -4330,7 +5385,7 @@ async function workspaceSetSuccessor(userIdOrNull, options) {
     const targetWs = await resolveSubcommandWorkspaceId(options, config);
     if (!targetWs) {
       console.error(
-        chalk10.red(
+        chalk11.red(
           "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
         )
       );
@@ -4347,7 +5402,7 @@ async function workspaceSetSuccessor(userIdOrNull, options) {
       return;
     }
     console.log(
-      chalk10.green(
+      chalk11.green(
         successorUserId ? `Successor set to ${successorUserId} for workspace ${result.name}.` : `Successor cleared for workspace ${result.name}.`
       )
     );
@@ -4361,7 +5416,7 @@ async function workspaceLeave(options) {
     const targetWs = await resolveSubcommandWorkspaceId(options, config);
     if (!targetWs) {
       console.error(
-        chalk10.red(
+        chalk11.red(
           "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
         )
       );
@@ -4369,7 +5424,7 @@ async function workspaceLeave(options) {
     }
     const selfId = await getSelfUserId(config);
     if (!selfId) {
-      console.error(chalk10.red("Error: could not resolve your user id -- are you authenticated?"));
+      console.error(chalk11.red("Error: could not resolve your user id -- are you authenticated?"));
       process.exit(2);
     }
     const ok = await confirm4(
@@ -4377,7 +5432,7 @@ async function workspaceLeave(options) {
       options.yes === true
     );
     if (!ok) {
-      console.log(chalk10.gray("Aborted."));
+      console.log(chalk11.gray("Aborted."));
       return;
     }
     const client = new ApiClient(config, { workspaceId: targetWs });
@@ -4390,7 +5445,7 @@ async function workspaceLeave(options) {
       console.log(JSON.stringify({ workspaceId: targetWs, left: true }, null, 2));
       return;
     }
-    console.log(chalk10.green(`Left workspace ${targetWs}.`));
+    console.log(chalk11.green(`Left workspace ${targetWs}.`));
   } catch (error) {
     exitWithError(error);
   }
@@ -4404,12 +5459,12 @@ function renderStructure(structure) {
   ];
   const totalFolders = sections.reduce((n, s) => n + s.folders.length, 0);
   if (totalFolders === 0) {
-    console.log(chalk10.yellow("Workspace is empty -- no folders found."));
+    console.log(chalk11.yellow("Workspace is empty -- no folders found."));
     return;
   }
   for (const { label, folders } of sections) {
     if (folders.length === 0) continue;
-    console.log(chalk10.bold.cyan(`
+    console.log(chalk11.bold.cyan(`
 ${label}`));
     for (const folder of folders) {
       console.log(`  ${folder}`);
@@ -4423,12 +5478,12 @@ function renderDeleteResult(result, json) {
     return;
   }
   if (result.status === "deleted") {
-    console.log(chalk10.green("Workspace deleted (cascade complete)."));
+    console.log(chalk11.green("Workspace deleted (cascade complete)."));
     return;
   }
   if (result.status === "pending-async") {
     console.log(
-      chalk10.green(
+      chalk11.green(
         `Workspace soft-deleted; large-cascade scheduled (job: ${result.jobId}). Membership has been revoked; data drain happens asynchronously.`
       )
     );
@@ -4436,7 +5491,7 @@ function renderDeleteResult(result, json) {
   }
   if (result.status === "transferred") {
     console.log(
-      chalk10.green(
+      chalk11.green(
         `Ownership transferred to ${result.workspace.ownerUserId}. New owner of '${result.workspace.name}'.`
       )
     );
@@ -4444,23 +5499,23 @@ function renderDeleteResult(result, json) {
   }
 }
 function renderDeleteConfirmMenu(resp) {
-  console.log(chalk10.bold("\nDelete workspace -- confirmation required"));
+  console.log(chalk11.bold("\nDelete workspace -- confirmation required"));
   console.log(`  Workspace: ${resp.workspace.name} (${resp.workspace.id})`);
   console.log(`  Members: ${resp.workspace.memberCount}`);
   console.log(`  Admins: ${resp.workspace.adminCount}`);
-  console.log(chalk10.bold("\nAvailable actions:"));
+  console.log(chalk11.bold("\nAvailable actions:"));
   for (const opt of resp.options) {
     if (opt.action === "transfer-to") {
       console.log(`  - transfer-to=<userId>   ${opt.label}`);
       if (opt.validRecipients && opt.validRecipients.length > 0) {
-        console.log(chalk10.gray(`      eligible: ${opt.validRecipients.join(", ")}`));
+        console.log(chalk11.gray(`      eligible: ${opt.validRecipients.join(", ")}`));
       }
     } else {
       console.log(`  - cascade-delete         ${opt.label}`);
     }
   }
   console.log(
-    chalk10.gray("\nRe-run with --confirm cascade-delete OR --confirm transfer-to=<userId>")
+    chalk11.gray("\nRe-run with --confirm cascade-delete OR --confirm transfer-to=<userId>")
   );
 }
 async function buildDeleteQueryString(action, targetWs, assumeYes) {
@@ -4470,7 +5525,7 @@ async function buildDeleteQueryString(action, targetWs, assumeYes) {
       assumeYes
     );
     if (!ok) {
-      console.log(chalk10.gray("Aborted."));
+      console.log(chalk11.gray("Aborted."));
       return void 0;
     }
     return "confirm=true&action=cascade-delete";
@@ -4478,13 +5533,13 @@ async function buildDeleteQueryString(action, targetWs, assumeYes) {
   if (action.startsWith("transfer-to=")) {
     const recipient = action.slice("transfer-to=".length);
     if (!recipient) {
-      console.error(chalk10.red("Error: --confirm transfer-to=<userId> requires a userId."));
+      console.error(chalk11.red("Error: --confirm transfer-to=<userId> requires a userId."));
       process.exit(1);
     }
     return `confirm=true&action=transfer-to&recipient=${encodeURIComponent(recipient)}`;
   }
   console.error(
-    chalk10.red(
+    chalk11.red(
       `Error: --confirm must be 'cascade-delete' or 'transfer-to=<userId>' (got: ${action})`
     )
   );
@@ -4497,7 +5552,7 @@ async function runDeletePhase1(client, targetWs, json) {
       console.log(JSON.stringify({ status: "deleted" }, null, 2));
       return;
     }
-    console.log(chalk10.green("Workspace deleted."));
+    console.log(chalk11.green("Workspace deleted."));
     return;
   }
   if (json) {
@@ -4522,7 +5577,7 @@ async function workspaceDelete(options) {
     const targetWs = await resolveSubcommandWorkspaceId(options, config);
     if (!targetWs) {
       console.error(
-        chalk10.red(
+        chalk11.red(
           "Error: no workspace selected. Use --workspace <id> or run `bisque workspace switch`."
         )
       );
@@ -4553,7 +5608,7 @@ async function workspaceDelete(options) {
       exitWithError(error);
     }
     const message = unwrapApiErrorMessage(error);
-    console.error(chalk10.red(`Error: ${message}`));
+    console.error(chalk11.red(`Error: ${message}`));
     process.exit(1);
   }
 }
@@ -4607,7 +5662,7 @@ function registerWorkspaceCommand(program2) {
       renderStructure(result.structure);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(chalk10.red(`Error: ${message}`));
+      console.error(chalk11.red(`Error: ${message}`));
       process.exitCode = 1;
     }
   });
@@ -4619,15 +5674,15 @@ function registerWorkspaceCommand(program2) {
         console.log(JSON.stringify(ws, null, 2));
         return;
       }
-      console.log(chalk10.bold("\nWorkspace Details\n"));
-      console.log(`${chalk10.cyan("ID:")}         ${ws.workspaceId}`);
-      console.log(`${chalk10.cyan("Name:")}       ${ws.name}`);
-      console.log(`${chalk10.cyan("User ID:")}    ${ws.userId}`);
-      console.log(`${chalk10.cyan("Created:")}    ${new Date(ws.createdAt).toLocaleString()}`);
-      console.log(`${chalk10.cyan("Updated:")}    ${new Date(ws.updatedAt).toLocaleString()}`);
+      console.log(chalk11.bold("\nWorkspace Details\n"));
+      console.log(`${chalk11.cyan("ID:")}         ${ws.workspaceId}`);
+      console.log(`${chalk11.cyan("Name:")}       ${ws.name}`);
+      console.log(`${chalk11.cyan("User ID:")}    ${ws.userId}`);
+      console.log(`${chalk11.cyan("Created:")}    ${new Date(ws.createdAt).toLocaleString()}`);
+      console.log(`${chalk11.cyan("Updated:")}    ${new Date(ws.updatedAt).toLocaleString()}`);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(chalk10.red(`Error: ${message}`));
+      console.error(chalk11.red(`Error: ${message}`));
       process.exitCode = 1;
     }
   });
@@ -4639,12 +5694,12 @@ function registerWorkspaceCommand(program2) {
         console.log(JSON.stringify(ws, null, 2));
         return;
       }
-      console.log(chalk10.bold("\nDefault Workspace\n"));
-      console.log(`${chalk10.cyan("ID:")}         ${ws.workspaceId}`);
-      console.log(`${chalk10.cyan("Name:")}       ${ws.name}`);
-      console.log(`${chalk10.cyan("User ID:")}    ${ws.userId}`);
-      console.log(`${chalk10.cyan("Created:")}    ${new Date(ws.createdAt).toLocaleString()}`);
-      console.log(`${chalk10.cyan("Updated:")}    ${new Date(ws.updatedAt).toLocaleString()}`);
+      console.log(chalk11.bold("\nDefault Workspace\n"));
+      console.log(`${chalk11.cyan("ID:")}         ${ws.workspaceId}`);
+      console.log(`${chalk11.cyan("Name:")}       ${ws.name}`);
+      console.log(`${chalk11.cyan("User ID:")}    ${ws.userId}`);
+      console.log(`${chalk11.cyan("Created:")}    ${new Date(ws.createdAt).toLocaleString()}`);
+      console.log(`${chalk11.cyan("Updated:")}    ${new Date(ws.updatedAt).toLocaleString()}`);
     } catch (error) {
       exitWithError(error);
     }
@@ -4685,6 +5740,7 @@ function registerCommands(program2) {
   registerPluginCommand(program2);
   registerSkillCommand(program2);
   registerMeasureCommand(program2);
+  registerDriftCommand(program2);
 }
 
 // src/index.ts