haansi 0.1.47 → 0.1.48

package/dist/haansi.js

@@ -95,7 +95,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "haansi",
-      version: "0.1.47",
+      version: "0.1.48",
       description: "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
       bin: {
         haansi: "./dist/haansi.js"
@@ -122,13 +122,693 @@ var require_package = __commonJS({
   }
 });
 
+// ../service-capture/common/agents/types.ts
+var AGENT_IDS;
+var init_types = __esm({
+  "../service-capture/common/agents/types.ts"() {
+    "use strict";
+    AGENT_IDS = ["claude-code", "codex"];
+  }
+});
+
+// ../service-capture/common/agents/claude-code.ts
+function projectsDir() {
+  return (0, import_path.join)((0, import_os.homedir)(), ".claude", "projects");
+}
+function extractMeta(filePath) {
+  const result = {
+    cwd: null,
+    timestamp: null,
+    gitBranch: null
+  };
+  try {
+    const lines = (0, import_fs.readFileSync)(filePath, "utf-8").split("\n").filter((l) => l.trim()).slice(0, 50);
+    for (const line of lines) {
+      try {
+        const entry2 = JSON.parse(line);
+        if (!result.cwd && typeof entry2.cwd === "string")
+          result.cwd = entry2.cwd;
+        if (!result.timestamp && typeof entry2.timestamp === "string")
+          result.timestamp = entry2.timestamp;
+        if (!result.gitBranch && typeof entry2.gitBranch === "string")
+          result.gitBranch = entry2.gitBranch;
+        if (result.cwd && result.timestamp && result.gitBranch) break;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+var import_fs, import_path, import_os, claudeCodeAgent;
+var init_claude_code = __esm({
+  "../service-capture/common/agents/claude-code.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+    import_os = require("os");
+    claudeCodeAgent = {
+      id: "claude-code",
+      displayName: "Claude Code",
+      sessionsRoot() {
+        return projectsDir();
+      },
+      isInstalled() {
+        return (0, import_fs.existsSync)(projectsDir());
+      },
+      discoverSessions() {
+        const root = projectsDir();
+        if (!(0, import_fs.existsSync)(root)) return [];
+        const sessions = [];
+        const projectDirs = (0, import_fs.readdirSync)(root).map((name) => (0, import_path.join)(root, name)).filter((p) => {
+          try {
+            return (0, import_fs.statSync)(p).isDirectory();
+          } catch {
+            return false;
+          }
+        });
+        for (const dir of projectDirs) {
+          let files;
+          try {
+            files = (0, import_fs.readdirSync)(dir).filter((f) => f.endsWith(".jsonl"));
+          } catch {
+            continue;
+          }
+          for (const file2 of files) {
+            const filePath = (0, import_path.join)(dir, file2);
+            const sessionId = (0, import_path.basename)(file2, ".jsonl");
+            try {
+              const stat = (0, import_fs.statSync)(filePath);
+              const content = (0, import_fs.readFileSync)(filePath, "utf-8");
+              const lineCount = content.split("\n").filter((l) => l.trim()).length;
+              const meta3 = extractMeta(filePath);
+              sessions.push({
+                sessionId,
+                filePath,
+                lineCount,
+                sizeBytes: stat.size,
+                ...meta3
+              });
+            } catch {
+            }
+          }
+        }
+        return sessions;
+      }
+    };
+  }
+});
+
+// ../service-capture/common/agents/codex.ts
+function codexHome() {
+  return process.env.CODEX_HOME || (0, import_path2.join)((0, import_os2.homedir)(), ".codex");
+}
+function sessionsDir() {
+  return (0, import_path2.join)(codexHome(), "sessions");
+}
+function walkRollouts(dir, out) {
+  let entries;
+  try {
+    entries = (0, import_fs2.readdirSync)(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const full = (0, import_path2.join)(dir, name);
+    let isDir = false;
+    try {
+      isDir = (0, import_fs2.statSync)(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir) {
+      walkRollouts(full, out);
+    } else if (name.startsWith("rollout-") && name.endsWith(".jsonl")) {
+      out.push(full);
+    }
+  }
+}
+function readRolloutMeta(filePath, content) {
+  const fileName = (0, import_path2.basename)(filePath, ".jsonl");
+  const fromName = UUID_RE.exec(fileName)?.[1];
+  let cwd = null;
+  let timestamp = null;
+  let gitBranch = null;
+  let gitRemoteUrl = null;
+  let gitCommit = null;
+  let metaId = null;
+  const lines = content.split("\n").filter((l) => l.trim()).slice(0, 50);
+  for (const line of lines) {
+    try {
+      const entry2 = JSON.parse(line);
+      if (!timestamp && typeof entry2.timestamp === "string") {
+        timestamp = entry2.timestamp;
+      }
+      const p = entry2.payload ?? {};
+      if (entry2.type === "session_meta") {
+        if (typeof p.cwd === "string") cwd = p.cwd;
+        if (typeof p.id === "string") metaId = p.id;
+        const g = p.git ?? {};
+        const branch = g.branch ?? p.git_branch;
+        if (typeof branch === "string") gitBranch = branch;
+        const remote = g.repository_url ?? g.remote_url;
+        if (typeof remote === "string") gitRemoteUrl = remote;
+        const commit = g.commit_hash ?? g.commit;
+        if (typeof commit === "string") gitCommit = commit;
+      }
+      if (cwd && gitBranch && gitCommit && timestamp && metaId) break;
+    } catch {
+    }
+  }
+  return {
+    sessionId: fromName ?? metaId ?? fileName,
+    cwd,
+    timestamp,
+    gitBranch,
+    gitRemoteUrl,
+    gitCommit
+  };
+}
+var import_fs2, import_path2, import_os2, UUID_RE, codexAgent;
+var init_codex = __esm({
+  "../service-capture/common/agents/codex.ts"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path2 = require("path");
+    import_os2 = require("os");
+    UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+    codexAgent = {
+      id: "codex",
+      displayName: "OpenAI Codex",
+      sessionsRoot() {
+        return sessionsDir();
+      },
+      isInstalled() {
+        return (0, import_fs2.existsSync)(codexHome());
+      },
+      discoverSessions() {
+        const root = sessionsDir();
+        if (!(0, import_fs2.existsSync)(root)) return [];
+        const files = [];
+        walkRollouts(root, files);
+        const sessions = [];
+        for (const filePath of files) {
+          try {
+            const stat = (0, import_fs2.statSync)(filePath);
+            const content = (0, import_fs2.readFileSync)(filePath, "utf-8");
+            const lineCount = content.split("\n").filter((l) => l.trim()).length;
+            const meta3 = readRolloutMeta(filePath, content);
+            sessions.push({
+              sessionId: meta3.sessionId,
+              filePath,
+              lineCount,
+              sizeBytes: stat.size,
+              cwd: meta3.cwd,
+              timestamp: meta3.timestamp,
+              gitBranch: meta3.gitBranch,
+              gitRemoteUrl: meta3.gitRemoteUrl,
+              gitCommit: meta3.gitCommit
+            });
+          } catch {
+          }
+        }
+        return sessions;
+      }
+    };
+  }
+});
+
+// ../service-capture/common/agents/registry.ts
+function getAgents() {
+  return AGENTS;
+}
+function getAgent(id) {
+  const agent = AGENTS.find((a) => a.id === id);
+  if (!agent) throw new Error(`Unknown agent: ${id}`);
+  return agent;
+}
+function detectInstalled() {
+  return AGENTS.filter((a) => a.isInstalled());
+}
+var AGENTS;
+var init_registry = __esm({
+  "../service-capture/common/agents/registry.ts"() {
+    "use strict";
+    init_claude_code();
+    init_codex();
+    AGENTS = [claudeCodeAgent, codexAgent];
+  }
+});
+
+// ../service-capture/common/agents/index.ts
+var agents_exports = {};
+__export(agents_exports, {
+  AGENT_IDS: () => AGENT_IDS,
+  claudeCodeAgent: () => claudeCodeAgent,
+  codexAgent: () => codexAgent,
+  detectInstalled: () => detectInstalled,
+  getAgent: () => getAgent,
+  getAgents: () => getAgents
+});
+var init_agents = __esm({
+  "../service-capture/common/agents/index.ts"() {
+    "use strict";
+    init_types();
+    init_claude_code();
+    init_codex();
+    init_registry();
+  }
+});
+
+// src/lib/agent-selection.ts
+var agent_selection_exports = {};
+__export(agent_selection_exports, {
+  parseAgentFlag: () => parseAgentFlag,
+  promptForAgents: () => promptForAgents,
+  readSavedAgents: () => readSavedAgents,
+  resolveAgentSelection: () => resolveAgentSelection,
+  saveAgents: () => saveAgents
+});
+function parseAgentFlag(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "both" || normalized === "all") return [...VALID];
+  const out = [];
+  for (const part of normalized.split(",").map((s) => s.trim())) {
+    if (part === "claude" || part === "claude-code") {
+      if (!out.includes("claude-code")) out.push("claude-code");
+    } else if (part === "codex") {
+      if (!out.includes("codex")) out.push("codex");
+    }
+  }
+  return out.length > 0 ? out : null;
+}
+function readSavedAgents() {
+  if (!(0, import_node_fs2.existsSync)(CONFIG_FILE)) return null;
+  try {
+    const cfg = JSON.parse((0, import_node_fs2.readFileSync)(CONFIG_FILE, "utf-8"));
+    if (Array.isArray(cfg.agents)) {
+      const agents = cfg.agents.filter(
+        (a) => VALID.includes(a)
+      );
+      return agents.length > 0 ? agents : null;
+    }
+  } catch {
+  }
+  return null;
+}
+function saveAgents(agents) {
+  let cfg = {};
+  if ((0, import_node_fs2.existsSync)(CONFIG_FILE)) {
+    try {
+      cfg = JSON.parse((0, import_node_fs2.readFileSync)(CONFIG_FILE, "utf-8"));
+    } catch {
+      cfg = {};
+    }
+  }
+  cfg.agents = agents;
+  (0, import_node_fs2.mkdirSync)(HAANSI_DIR, { recursive: true });
+  (0, import_node_fs2.writeFileSync)(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function resolveAgentSelection(flagValue) {
+  const fromFlag = parseAgentFlag(flagValue);
+  if (fromFlag) return { agents: fromFlag, source: "flag" };
+  const saved = readSavedAgents();
+  if (saved) return { agents: saved, source: "config" };
+  const detected = detectInstalled().map((a) => a.id);
+  if (detected.length > 0) return { agents: detected, source: "detected" };
+  return { agents: ["claude-code"], source: "default" };
+}
+async function promptForAgents() {
+  const installed = new Set(detectInstalled().map((a) => a.id));
+  const agents = getAgents();
+  console.log("\nWhich coding agents should Haansi connect?\n");
+  agents.forEach((a, i) => {
+    const mark = installed.has(a.id) ? "installed" : "not detected";
+    console.log(`  ${i + 1}) ${a.displayName} (${mark})`);
+  });
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await new Promise((resolve5) => {
+    rl.question(
+      "\nEnter numbers (comma-separated), or press Enter for all installed: ",
+      (a) => {
+        rl.close();
+        resolve5(a.trim());
+      }
+    );
+  });
+  if (!answer) {
+    const detected = agents.filter((a) => installed.has(a.id)).map((a) => a.id);
+    return detected.length > 0 ? detected : [...VALID];
+  }
+  const picked = [];
+  for (const token of answer.split(",").map((s) => s.trim())) {
+    const idx = parseInt(token, 10) - 1;
+    const agent = agents[idx];
+    if (agent && !picked.includes(agent.id)) picked.push(agent.id);
+  }
+  return picked.length > 0 ? picked : [...VALID];
+}
+var import_node_fs2, readline, VALID;
+var init_agent_selection = __esm({
+  "src/lib/agent-selection.ts"() {
+    "use strict";
+    import_node_fs2 = require("node:fs");
+    readline = __toESM(require("node:readline"));
+    init_agents();
+    init_paths();
+    VALID = ["claude-code", "codex"];
+  }
+});
+
+// src/lib/codex-config.ts
+function tomlString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+  return `"${escaped}"`;
+}
+function tomlStringArray(values) {
+  return `[${values.map(tomlString).join(", ")}]`;
+}
+function tomlInlineTable(entries) {
+  const parts = Object.entries(entries).map(
+    ([k, v]) => `${k} = ${tomlString(v)}`
+  );
+  return `{ ${parts.join(", ")} }`;
+}
+function upsertTomlTable(content, tablePath, entries) {
+  const bodyLines = Object.entries(entries).map(([k, v]) => `${k} = ${v}`);
+  const block = [`[${tablePath}]`, ...bodyLines].join("\n");
+  const lines = content.split("\n");
+  const headerRe = new RegExp(
+    `^\\s*\\[\\s*${tablePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\]\\s*$`
+  );
+  const startIdx = lines.findIndex((l) => headerRe.test(l));
+  if (startIdx === -1) {
+    const trimmed = content.replace(/\s*$/, "");
+    return trimmed.length > 0 ? `${trimmed}
+
+${block}
+` : `${block}
+`;
+  }
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (/^\s*\[/.test(lines[i])) {
+      endIdx = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, startIdx);
+  const after = lines.slice(endIdx);
+  const rebuilt = [...before, ...block.split("\n"), ...after].join("\n");
+  return rebuilt.replace(/\n{3,}/g, "\n\n");
+}
+var init_codex_config = __esm({
+  "src/lib/codex-config.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/setup-mcp.ts
+var setup_mcp_exports = {};
+__export(setup_mcp_exports, {
+  HTTP_SERVERS: () => HTTP_SERVERS,
+  parseTarget: () => parseTarget,
+  refreshClaudeConfigTokens: () => refreshClaudeConfigTokens,
+  refreshCodexConfigTokens: () => refreshCodexConfigTokens,
+  refreshMcpTokens: () => refreshMcpTokens,
+  setupMcp: () => setupMcp
+});
+function parseTarget(arg) {
+  if (!arg || arg === "all") return "all";
+  if (arg === "solutions" || arg === "exchange" || arg === "digests" || arg === "onboarding" || arg === "skills")
+    return arg;
+  throw new Error(
+    `Unknown target: ${arg}. Use one of: solutions, exchange, digests, onboarding, skills, all (default).`
+  );
+}
+function httpServerUrl(path2) {
+  return `${apiUrl().replace(/\/+$/, "")}${path2}`;
+}
+function setupClaudeMcp(target) {
+  let config6 = {};
+  if ((0, import_node_fs3.existsSync)(CLAUDE_JSON)) {
+    try {
+      config6 = JSON.parse((0, import_node_fs3.readFileSync)(CLAUDE_JSON, "utf-8"));
+    } catch {
+      console.error(
+        `Warning: Could not parse ${CLAUDE_JSON} \u2014 will overwrite with new config.`
+      );
+    }
+  }
+  if (!config6.mcpServers) config6.mcpServers = {};
+  const installed = [];
+  const warnings = [];
+  if (target === "all" || target === "solutions") {
+    const haansiBin = resolveHaansiBin();
+    config6.mcpServers["haansi-solutions"] = {
+      command: haansiBin,
+      args: ["mcp-server"],
+      env: { HAANSI_AGENT_SOURCE: "claude-code" }
+    };
+    installed.push(`haansi-solutions (stdio \u2192 ${haansiBin} mcp-server)`);
+  }
+  for (const http of HTTP_SERVERS) {
+    if (target !== "all" && target !== http.target) continue;
+    const token = resolveToken();
+    if (!token) {
+      warnings.push(
+        `${http.name} not registered: no token found. Run \`haansi auth login\` first, or set HAANSI_TOKEN.`
+      );
+      continue;
+    }
+    const url2 = httpServerUrl(http.path);
+    config6.mcpServers[http.name] = {
+      type: "http",
+      url: url2,
+      headers: { Authorization: `Bearer ${token}` }
+    };
+    installed.push(`${http.name} (http \u2192 ${url2})`);
+  }
+  (0, import_node_fs3.writeFileSync)(CLAUDE_JSON, JSON.stringify(config6, null, 2) + "\n", "utf-8");
+  console.log(`
+Claude Code \u2014 configured in ${CLAUDE_JSON}`);
+  for (const entry2 of installed) console.log(`  \u2022 ${entry2}`);
+  for (const w of warnings) console.log(`  ! ${w}`);
+  return { installed, warnings };
+}
+function setupCodexMcp(target) {
+  let content = "";
+  if ((0, import_node_fs3.existsSync)(CODEX_CONFIG)) {
+    try {
+      content = (0, import_node_fs3.readFileSync)(CODEX_CONFIG, "utf-8");
+    } catch {
+      console.error(
+        `Warning: Could not read ${CODEX_CONFIG} \u2014 will create a new file.`
+      );
+    }
+  }
+  const installed = [];
+  const warnings = [];
+  if (target === "all" || target === "solutions") {
+    const haansiBin = resolveHaansiBin();
+    content = upsertTomlTable(content, "mcp_servers.haansi-solutions", {
+      command: tomlString(haansiBin),
+      args: tomlStringArray(["mcp-server"]),
+      env: tomlInlineTable({ HAANSI_AGENT_SOURCE: "codex" })
+    });
+    installed.push(`haansi-solutions (stdio \u2192 ${haansiBin} mcp-server)`);
+  }
+  for (const http of HTTP_SERVERS) {
+    if (target !== "all" && target !== http.target) continue;
+    const token = resolveToken();
+    if (!token) {
+      warnings.push(
+        `${http.name} not registered: no token found. Run \`haansi auth login\` first, or set HAANSI_TOKEN.`
+      );
+      continue;
+    }
+    const url2 = httpServerUrl(http.path);
+    content = upsertTomlTable(content, `mcp_servers.${http.name}`, {
+      url: tomlString(url2),
+      http_headers: tomlInlineTable({ Authorization: `Bearer ${token}` })
+    });
+    installed.push(`${http.name} (http \u2192 ${url2})`);
+  }
+  (0, import_node_fs3.mkdirSync)(CODEX_HOME, { recursive: true });
+  (0, import_node_fs3.writeFileSync)(CODEX_CONFIG, content, "utf-8");
+  console.log(`
+OpenAI Codex \u2014 configured in ${CODEX_CONFIG}`);
+  for (const entry2 of installed) console.log(`  \u2022 ${entry2}`);
+  for (const w of warnings) console.log(`  ! ${w}`);
+  return { installed, warnings };
+}
+function refreshClaudeConfigTokens(config6, token) {
+  const changed = [];
+  const scopes = [
+    config6.mcpServers,
+    ...Object.values(config6.projects ?? {}).map(
+      (p) => p?.mcpServers
+    )
+  ];
+  for (const servers of scopes) {
+    if (!servers || typeof servers !== "object") continue;
+    for (const [name, entry2] of Object.entries(
+      servers
+    )) {
+      if (!HTTP_SERVER_NAMES.has(name)) continue;
+      const auth = entry2?.headers?.Authorization;
+      if (typeof auth !== "string" || !HSK_BEARER.test(auth)) continue;
+      const next = `Bearer ${token}`;
+      if (auth === next) continue;
+      entry2.headers.Authorization = next;
+      changed.push(name);
+    }
+  }
+  return changed;
+}
+function refreshCodexConfigTokens(content, token) {
+  const changed = [];
+  const lines = content.split("\n");
+  let current = null;
+  for (let i = 0; i < lines.length; i++) {
+    const header = /^\s*\[\s*mcp_servers\.([^\]\s]+)\s*\]\s*$/.exec(lines[i]);
+    if (header) {
+      current = HTTP_SERVER_NAMES.has(header[1]) ? header[1] : null;
+      continue;
+    }
+    if (/^\s*\[/.test(lines[i])) {
+      current = null;
+      continue;
+    }
+    if (!current || !HSK_BEARER.test(lines[i])) continue;
+    const next = lines[i].replace(HSK_BEARER, `Bearer ${token}`);
+    if (next !== lines[i]) {
+      lines[i] = next;
+      if (!changed.includes(current)) changed.push(current);
+    }
+  }
+  return { content: lines.join("\n"), changed };
+}
+function refreshMcpTokens(token, files = {}) {
+  const claudeJson = files.claudeJson ?? CLAUDE_JSON;
+  const codexConfig = files.codexConfig ?? CODEX_CONFIG;
+  const updated = [];
+  try {
+    if ((0, import_node_fs3.existsSync)(claudeJson)) {
+      const config6 = JSON.parse((0, import_node_fs3.readFileSync)(claudeJson, "utf-8"));
+      const changed = refreshClaudeConfigTokens(config6, token);
+      if (changed.length > 0) {
+        (0, import_node_fs3.writeFileSync)(
+          claudeJson,
+          JSON.stringify(config6, null, 2) + "\n",
+          "utf-8"
+        );
+        updated.push(...changed.map((n) => `Claude Code: ${n}`));
+      }
+    }
+  } catch {
+    console.error(
+      `Warning: could not update the MCP token in ${claudeJson}. Run \`haansi setup-mcp\`.`
+    );
+  }
+  try {
+    if ((0, import_node_fs3.existsSync)(codexConfig)) {
+      const result = refreshCodexConfigTokens(
+        (0, import_node_fs3.readFileSync)(codexConfig, "utf-8"),
+        token
+      );
+      if (result.changed.length > 0) {
+        (0, import_node_fs3.writeFileSync)(codexConfig, result.content, "utf-8");
+        updated.push(...result.changed.map((n) => `Codex: ${n}`));
+      }
+    }
+  } catch {
+    console.error(
+      `Warning: could not update the MCP token in ${codexConfig}. Run \`haansi setup-mcp\`.`
+    );
+  }
+  if (updated.length > 0) {
+    console.log("Updated the token for your Haansi MCP servers:");
+    for (const u of updated) console.log(`  \u2022 ${u}`);
+    console.log(
+      "Restart your coding agent (or reconnect with /mcp) to use it."
+    );
+  }
+  return updated;
+}
+async function setupMcp(targetArg, agentFlag) {
+  const target = parseTarget(targetArg);
+  const selection = resolveAgentSelection(agentFlag);
+  for (const agentId of selection.agents) {
+    WRITERS[agentId](target);
+  }
+  saveAgents(selection.agents);
+  const restart = selection.agents.map((a) => a === "codex" ? "Codex" : "Claude Code").join(" / ");
+  console.log(`
+Restart ${restart} to activate the changes.`);
+}
+var import_node_fs3, import_node_path2, import_node_os2, CLAUDE_JSON, CODEX_HOME, CODEX_CONFIG, HTTP_SERVERS, HSK_BEARER, HTTP_SERVER_NAMES, WRITERS;
+var init_setup_mcp = __esm({
+  "src/commands/setup-mcp.ts"() {
+    "use strict";
+    import_node_fs3 = require("node:fs");
+    import_node_path2 = require("node:path");
+    import_node_os2 = require("node:os");
+    init_paths();
+    init_agent_selection();
+    init_codex_config();
+    CLAUDE_JSON = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".claude.json");
+    CODEX_HOME = process.env.CODEX_HOME || (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".codex");
+    CODEX_CONFIG = (0, import_node_path2.join)(CODEX_HOME, "config.toml");
+    HTTP_SERVERS = [
+      {
+        target: "exchange",
+        name: "haansi-exchange",
+        path: "/api/v1/memory/exchange/mcp"
+      },
+      {
+        target: "digests",
+        name: "haansi-digests",
+        path: "/api/v1/memory/digests/mcp"
+      },
+      // Published onboarding guides, so an agent can pick up a workstream from
+      // its handoff doc (docs/product/plans/2026-09-24-onboarding-guides.md §8.3).
+      {
+        target: "onboarding",
+        name: "haansi-onboarding",
+        path: "/api/v1/memory/onboarding/mcp"
+      },
+      // Published team skills, loaded progressively by coding agents
+      // (docs/product/plans/2026-10-10-memory-skills.md §7).
+      {
+        target: "skills",
+        name: "haansi-skills",
+        path: "/api/v1/memory/skills/mcp"
+      }
+    ];
+    HSK_BEARER = /Bearer hsk_[A-Za-z0-9_-]+/;
+    HTTP_SERVER_NAMES = new Set(HTTP_SERVERS.map((s) => s.name));
+    WRITERS = {
+      "claude-code": setupClaudeMcp,
+      codex: setupCodexMcp
+    };
+  }
+});
+
 // src/commands/auth-login.ts
 var auth_login_exports = {};
 __export(auth_login_exports, {
   authLogin: () => authLogin
 });
 function openBrowser(url2) {
-  const cmd = (0, import_node_os2.platform)() === "darwin" ? "open" : (0, import_node_os2.platform)() === "win32" ? "start" : "xdg-open";
+  const cmd = (0, import_node_os3.platform)() === "darwin" ? "open" : (0, import_node_os3.platform)() === "win32" ? "start" : "xdg-open";
   try {
     (0, import_node_child_process2.exec)(`${cmd} ${JSON.stringify(url2)}`);
     return true;
@@ -218,8 +898,8 @@ If the browser didn't open, visit this URL:
     );
   }
   const { token: hskToken } = await tokenRes.json();
-  (0, import_node_fs2.mkdirSync)(HAANSI_DIR2, { recursive: true });
-  (0, import_node_fs2.writeFileSync)(
+  (0, import_node_fs4.mkdirSync)(HAANSI_DIR2, { recursive: true });
+  (0, import_node_fs4.writeFileSync)(
     CREDENTIALS_FILE2,
     JSON.stringify({ token: hskToken }, null, 2),
     {
@@ -230,21 +910,23 @@ If the browser didn't open, visit this URL:
   console.log(`
 Authenticated successfully${orgName ? ` (${orgName})` : ""}!`);
   console.log(`Token saved to ${CREDENTIALS_FILE2}`);
+  refreshMcpTokens(hskToken);
   console.log(
     "Run `haansi collect` to upload sessions or `haansi setup-mcp` to configure Claude Code."
   );
 }
-var import_node_child_process2, import_node_fs2, import_node_path2, import_node_os2, HAANSI_DIR2, CREDENTIALS_FILE2, POLL_INTERVAL_MS, TIMEOUT_MS;
+var import_node_child_process2, import_node_fs4, import_node_path3, import_node_os3, HAANSI_DIR2, CREDENTIALS_FILE2, POLL_INTERVAL_MS, TIMEOUT_MS;
 var init_auth_login = __esm({
   "src/commands/auth-login.ts"() {
     "use strict";
     import_node_child_process2 = require("node:child_process");
-    import_node_fs2 = require("node:fs");
-    import_node_path2 = require("node:path");
-    import_node_os2 = require("node:os");
+    import_node_fs4 = require("node:fs");
+    import_node_path3 = require("node:path");
+    import_node_os3 = require("node:os");
     init_paths();
-    HAANSI_DIR2 = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".haansi");
-    CREDENTIALS_FILE2 = (0, import_node_path2.join)(HAANSI_DIR2, "credentials.json");
+    init_setup_mcp();
+    HAANSI_DIR2 = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".haansi");
+    CREDENTIALS_FILE2 = (0, import_node_path3.join)(HAANSI_DIR2, "credentials.json");
     POLL_INTERVAL_MS = 2e3;
     TIMEOUT_MS = 5 * 60 * 1e3;
   }
@@ -256,7 +938,7 @@ __export(init_exports, {
   init: () => init
 });
 function prompt(question) {
-  const rl = readline.createInterface({
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
@@ -304,28 +986,30 @@ async function init() {
   }
   console.log("\nValidating token...");
   await validateToken(token, apiUrl2);
-  (0, import_node_fs3.mkdirSync)(HAANSI_DIR3, { recursive: true });
-  (0, import_node_fs3.writeFileSync)(CREDENTIALS_FILE3, JSON.stringify({ token }, null, 2), {
+  (0, import_node_fs5.mkdirSync)(HAANSI_DIR3, { recursive: true });
+  (0, import_node_fs5.writeFileSync)(CREDENTIALS_FILE3, JSON.stringify({ token }, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
   console.log(`
 Token saved to ${CREDENTIALS_FILE3}`);
+  refreshMcpTokens(token);
   console.log(
     "Run `haansi daemon` to start collecting or `haansi setup-mcp` to configure your coding agent(s) (Claude Code / Codex)."
   );
 }
-var readline, import_node_fs3, import_node_path3, import_node_os3, HAANSI_DIR3, CREDENTIALS_FILE3;
+var readline2, import_node_fs5, import_node_path4, import_node_os4, HAANSI_DIR3, CREDENTIALS_FILE3;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
-    readline = __toESM(require("node:readline"));
-    import_node_fs3 = require("node:fs");
-    import_node_path3 = require("node:path");
-    import_node_os3 = require("node:os");
+    readline2 = __toESM(require("node:readline"));
+    import_node_fs5 = require("node:fs");
+    import_node_path4 = require("node:path");
+    import_node_os4 = require("node:os");
     init_paths();
-    HAANSI_DIR3 = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".haansi");
-    CREDENTIALS_FILE3 = (0, import_node_path3.join)(HAANSI_DIR3, "credentials.json");
+    init_setup_mcp();
+    HAANSI_DIR3 = (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".haansi");
+    CREDENTIALS_FILE3 = (0, import_node_path4.join)(HAANSI_DIR3, "credentials.json");
   }
 });
 
@@ -765,7 +1449,7 @@ var init_esm_node = __esm({
 });
 
 // ../../packages/@company/observability/src/types.ts
-var init_types = __esm({
+var init_types2 = __esm({
   "../../packages/@company/observability/src/types.ts"() {
     "use strict";
   }
@@ -1028,7 +1712,7 @@ var init_logger = __esm({
     "use strict";
     import_async_hooks = require("async_hooks");
     init_esm_node();
-    init_types();
+    init_types2();
     SENSITIVE_KEY_RE = /^(password|passwd|secret|token|apikey|authorization|auth|authtoken|authkey|credentials?|connectionstring|privatekey)$/;
     USER_CONTENT_KEY_RE = /^(question|questiontext|query|querytext|q|searchquery|searchtext|searchterm|searchterms|userquery|prompt|userprompt|usermessage|messagetext|messagecontent)$/;
     FIRST_LINE_CAUSE_CHARS = 300;
@@ -1232,7 +1916,7 @@ var _cloudBackend2, MetricsService;
 var init_metrics = __esm({
   "../../packages/@company/observability/src/metrics.ts"() {
     "use strict";
-    init_types();
+    init_types2();
     MetricsService = class {
       projectId;
       serviceName;
@@ -1526,7 +2210,7 @@ var init_observability_service = __esm({
     "use strict";
     init_logger();
     init_metrics();
-    init_types();
+    init_types2();
     ObservabilityService = class {
       logger;
       metrics;
@@ -1713,7 +2397,7 @@ var SCALING_METRICS_SERVICE, SCALING_METRICS_NAMESPACE, SCALING_METRICS;
 var init_scaling_metrics = __esm({
   "../../packages/@company/observability/src/scaling-metrics.ts"() {
     "use strict";
-    init_types();
+    init_types2();
     SCALING_METRICS_SERVICE = "backlog-reconciler";
     SCALING_METRICS_NAMESPACE = `Haansi/${SCALING_METRICS_SERVICE}`;
     SCALING_METRICS = {
@@ -1736,7 +2420,7 @@ var init_scaling_metrics = __esm({
       REPLAY_PENDING_EVENTS: spec({
         name: "haansi/replay/pending_events",
         unit: "Count",
-        description: "source_events a RUNNING re-run (live hard-reset lease) has yet to replay, past its watermark, all orgs.",
+        description: "source_events a RUNNING replay (live re-run lease, or a checkpoint saved within the heartbeat) has yet to replay, past its watermark, all orgs.",
         dimensions: ["environment"],
         treatMissingData: "breaching",
         missingDataRationale: "A re-run embeds every event inline through the batch embedders, but those rows are already normalized and never become claims, so neither backlog_rows nor claims_pending nor canonical_backlog_events can see the demand: one TEI task served a whole re-run at ~1 s/text (dev 2026-10-06). This is the only publisher of that demand; silence means it is unobserved, not finished. Breaching keeps the embedders up."
@@ -2038,7 +2722,7 @@ var init_health = __esm({
 var init_degradation = __esm({
   "../../packages/@company/observability/src/degradation.ts"() {
     "use strict";
-    init_types();
+    init_types2();
     init_observability_service();
   }
 });
@@ -2056,7 +2740,7 @@ var init_src2 = __esm({
     init_public_error();
     init_health();
     init_degradation();
-    init_types();
+    init_types2();
     defaultObservability = null;
     getDefaultObservability = () => {
       if (!defaultObservability) {
@@ -16580,9 +17264,1623 @@ var init_read_gate = __esm({
 });
 
 // ../../packages/@company/encryption/src/exclusions.ts
+function exchangeExclusions(database, table, columns) {
+  return Object.entries(columns).map(([column, [category, reason]]) => ({
+    database,
+    table,
+    column,
+    category,
+    reason
+  }));
+}
+var EXCHANGE_CONTENT_REASON, EXCHANGE_VOCAB_REASON, EXCHANGE_LABEL_REASON, EXCHANGE_AUDIT_REASON, INTEL, EXCHANGE_QA_EXCLUSIONS, EXPLICIT_EXCLUSIONS;
 var init_exclusions = __esm({
   "../../packages/@company/encryption/src/exclusions.ts"() {
     "use strict";
+    EXCHANGE_CONTENT_REASON = "Exchange content published across orgs after redaction (exchange-redesign \xA75). Every org reads it, so per-org encryption cannot apply; the redaction pipeline is the control.";
+    EXCHANGE_VOCAB_REASON = "A fixed vocabulary checked by a constraint; queries route and count on it.";
+    EXCHANGE_LABEL_REASON = "A descriptive label for an agent client (e.g. an MCP client name) or a fixed taxonomy facet, shown next to a contribution; not personal content.";
+    EXCHANGE_AUDIT_REASON = "An audit field describing a platform moderation or worker action on Exchange content, written by our doorways; audit queries filter on it.";
+    INTEL = "haansi_intelligence_prod";
+    EXCHANGE_QA_EXCLUSIONS = [
+      ...exchangeExclusions(INTEL, "exchange_posts", {
+        post_type: ["operational", EXCHANGE_VOCAB_REASON],
+        author_kind: ["operational", EXCHANGE_VOCAB_REASON],
+        agent_label: ["not-personal", EXCHANGE_LABEL_REASON],
+        disciplines: ["operational", EXCHANGE_LABEL_REASON],
+        work_functions: ["operational", EXCHANGE_LABEL_REASON],
+        desired_outcome: ["not-personal", EXCHANGE_CONTENT_REASON],
+        constraints_text: ["not-personal", EXCHANGE_CONTENT_REASON],
+        tried: ["not-personal", EXCHANGE_CONTENT_REASON]
+      }),
+      ...exchangeExclusions(INTEL, "exchange_answers", {
+        author_kind: ["operational", EXCHANGE_VOCAB_REASON],
+        moderation_status: ["operational", EXCHANGE_VOCAB_REASON],
+        agent_label: ["not-personal", EXCHANGE_LABEL_REASON],
+        approach: ["not-personal", EXCHANGE_CONTENT_REASON],
+        steps: ["not-personal", EXCHANGE_CONTENT_REASON],
+        limitations: ["not-personal", EXCHANGE_CONTENT_REASON]
+      }),
+      ...exchangeExclusions(INTEL, "exchange_revisions", {
+        editor_kind: ["operational", EXCHANGE_VOCAB_REASON],
+        redaction_version: ["operational", EXCHANGE_VOCAB_REASON],
+        content: ["not-personal", EXCHANGE_CONTENT_REASON]
+      }),
+      ...exchangeExclusions(INTEL, "exchange_comments", {
+        author_kind: ["operational", EXCHANGE_VOCAB_REASON],
+        moderation_status: ["operational", EXCHANGE_VOCAB_REASON],
+        body: ["not-personal", EXCHANGE_CONTENT_REASON]
+      }),
+      ...exchangeExclusions(INTEL, "exchange_reuse_events", {
+        actor_kind: ["operational", EXCHANGE_VOCAB_REASON],
+        outcome: ["operational", EXCHANGE_VOCAB_REASON],
+        evidence_kind: ["operational", EXCHANGE_VOCAB_REASON],
+        agent_label: ["not-personal", EXCHANGE_LABEL_REASON],
+        context: ["not-personal", EXCHANGE_CONTENT_REASON],
+        note: ["not-personal", EXCHANGE_CONTENT_REASON],
+        idempotency_key: [
+          "operational",
+          "A client-chosen retry key, compared by equality to dedupe a write; carries no content."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "exchange_reports", {
+        target_kind: ["operational", EXCHANGE_VOCAB_REASON],
+        reason: ["operational", EXCHANGE_VOCAB_REASON],
+        detail: [
+          "not-personal",
+          "A reporter's note about Exchange content, read only by the reporter and platform moderators."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "exchange_audit_outbox", {
+        actor_kind: ["audit-actor", EXCHANGE_AUDIT_REASON],
+        worker_name: ["audit-actor", EXCHANGE_AUDIT_REASON],
+        action: ["operational", EXCHANGE_AUDIT_REASON],
+        target_kind: ["operational", EXCHANGE_AUDIT_REASON],
+        reason: ["operational", EXCHANGE_AUDIT_REASON],
+        before_state: ["operational", EXCHANGE_AUDIT_REASON],
+        after_state: ["operational", EXCHANGE_AUDIT_REASON]
+      }),
+      ...exchangeExclusions("haansi_prod", "exchange_moderation_log", {
+        actor_kind: ["audit-actor", EXCHANGE_AUDIT_REASON],
+        worker_name: ["audit-actor", EXCHANGE_AUDIT_REASON],
+        target_kind: ["operational", EXCHANGE_AUDIT_REASON],
+        reason: ["operational", EXCHANGE_AUDIT_REASON],
+        before_state: ["operational", EXCHANGE_AUDIT_REASON],
+        after_state: ["operational", EXCHANGE_AUDIT_REASON]
+      })
+    ];
+    EXPLICIT_EXCLUSIONS = [
+      ...EXCHANGE_QA_EXCLUSIONS,
+      // ── cli_tokens (cli-token-scopes/001): delegated scopes ──
+      {
+        database: "haansi_prod",
+        table: "cli_tokens",
+        column: "scopes",
+        category: "operational",
+        reason: "A fixed vocabulary of delegated permissions ('exchange:write'), checked by a constraint and read on every request to authorize writes."
+      },
+      // ── qna_messages (qna-charts/003): answer dependency manifest ──
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_messages",
+        column: "dependency_manifest",
+        category: "operational",
+        reason: "Tool names and artifact ids an answer was built from (no content); read on every follow-up to re-check access, server-side only."
+      },
+      // ── organization_mcp_servers (custom-mcp-servers/004): Q&A tool allowlist ──
+      {
+        database: "haansi_prod",
+        table: "organization_mcp_servers",
+        column: "tool_policy",
+        category: "operational",
+        reason: "An admin's map of a server's tool names to 'read' | 'write' (shape-checked, no free text); read on every ask to decide which tools Q&A may offer."
+      },
+      // ── qna_write_operations (qna-charts/002): retry-safe Q&A writes ──
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_write_operations",
+        column: "operation_id",
+        category: "join-key",
+        reason: "Server-assigned key of one Q&A tool action: '<question id>:<tool name>'. Matched by equality on every retry."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_write_operations",
+        column: "tool",
+        category: "operational",
+        reason: "Name of the built-in tool that wrote (e.g. create_artifact); a fixed vocabulary."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_write_operations",
+        column: "payload_fingerprint",
+        category: "derived",
+        reason: "sha256 of the tool payload, compared by equality to tell a retry from a changed request. Encrypting it would break the comparison; the payload itself is not stored."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_write_operations",
+        column: "state",
+        category: "operational",
+        reason: "'claimed' | 'done' (CHECK-constrained)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_write_operations",
+        column: "surface",
+        category: "operational",
+        reason: "Product surface the write came from (web, slack, vscode, cli)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_write_operations",
+        column: "notify_state",
+        category: "operational",
+        reason: "Outbox delivery state (CHECK-constrained vocabulary)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_write_operations",
+        column: "notify_error",
+        category: "operational",
+        reason: "Error class name or a fixed sweep message; never message text or a Slack response body."
+      },
+      // ── slack_user_links (slack-installations/005): verified Slack ↔ member links ──
+      {
+        database: "haansi_prod",
+        table: "slack_user_links",
+        column: "team_id",
+        category: "join-key",
+        reason: "The Slack workspace id, the same key as organization_integrations.source_account_id; matched by equality on every bot event."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_user_links",
+        column: "slack_user_id",
+        category: "join-key",
+        reason: "Slack user id (U\u2026), a pseudonymous platform identifier looked up by equality on every bot event, the same shape as source_entity_id."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_user_links",
+        column: "link_source",
+        category: "operational",
+        reason: "A fixed enumeration (CHECK) of how the link was made; routes nothing personal."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_user_links",
+        column: "revoked_reason",
+        category: "operational",
+        reason: "A short code written by our own code (e.g. 'relinked'); never user text."
+      },
+      // ── slack_installations (slack-installations/001): the workspace's own
+      // installation record. Platform-level, no org; holds Slack-issued ids and
+      // the credential ciphertext. ──
+      {
+        database: "haansi_prod",
+        table: "slack_installations",
+        column: "credentials_encrypted",
+        category: "derived",
+        reason: "Already encrypted by the application before it is stored, like organization_integrations.credentials_encrypted; encrypting the ciphertext again adds nothing."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_installations",
+        column: "team_id",
+        category: "join-key",
+        reason: "The Slack workspace id, the SAME key as organization_integrations.source_account_id for slack rows and workspace_organization_mapping.workspace_id; looked up by equality on every bot event."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_installations",
+        column: "app_id",
+        category: "operational",
+        reason: "Slack's id for OUR app (A\u2026), the same value in every row."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_installations",
+        column: "enterprise_id",
+        category: "join-key",
+        reason: "Slack Enterprise Grid org id (E\u2026), a pseudonymous workspace-level identifier matched by equality; NULL for ordinary workspaces."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_installations",
+        column: "bot_user_id",
+        category: "operational",
+        reason: "The bot's own Slack user id (U\u2026), needed in plaintext for Bolt to ignore its own messages. Identifies our bot, not a person."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_installations",
+        column: "bot_id",
+        category: "operational",
+        reason: "The bot's own Slack bot id (B\u2026); identifies our bot, not a person."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_installations",
+        column: "scopes",
+        category: "operational",
+        reason: "Granted OAuth scopes, a fixed list from the manifest; read to decide whether a reinstall is needed."
+      },
+      {
+        database: "haansi_prod",
+        table: "slack_installations",
+        column: "installed_by_user_id",
+        category: "join-key",
+        reason: "Slack user id (U\u2026) of the admin who installed the app \u2014 a pseudonymous platform identifier, the same shape as source_entity_id elsewhere; used to attribute the install, never displayed."
+      },
+      // ── TI-58 runtime credential (WS9): already ciphertext ──
+      {
+        database: "haansi_prod",
+        table: "organization_database_configs",
+        column: "runtime_user_encrypted",
+        category: "derived",
+        reason: "Already encrypted by the application before it is stored, like the existing BYOD credential columns; encrypting the ciphertext again adds nothing."
+      },
+      {
+        database: "haansi_prod",
+        table: "organization_database_configs",
+        column: "runtime_password_encrypted",
+        category: "derived",
+        reason: "Already encrypted by the application before it is stored, like the existing BYOD credential columns; encrypting the ciphertext again adds nothing."
+      },
+      // ── exchange_moderation_log (TI-18): an audit trail of OUR actions ──
+      {
+        database: "haansi_prod",
+        table: "exchange_moderation_log",
+        column: "action",
+        category: "operational",
+        reason: "A fixed vocabulary of moderation actions ('delete_post'), checked by a constraint. Audit queries filter on it."
+      },
+      {
+        database: "haansi_prod",
+        table: "exchange_moderation_log",
+        column: "target_id",
+        category: "structural",
+        reason: "The id of the moderated Exchange post. An identifier the audit is looked up by, not content."
+      },
+      // ── session_object_pointers (WS6 phase 1): object locations, not content ──
+      {
+        database: "haansi_prod",
+        table: "session_object_pointers",
+        column: "user_id",
+        category: "structural",
+        reason: "The owning user's id, kept as text because it is part of the object key. An identifier the readers and the purge filter on, not personal content."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_pointers",
+        column: "session_id",
+        category: "structural",
+        reason: "The session id that names the object. Readers and the purge filter on it; it carries no content."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_pointers",
+        column: "bucket_kind",
+        category: "operational",
+        reason: "Which bucket the pointer names ('staging' or 'clean'). Routing state."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_pointers",
+        column: "object_key",
+        category: "structural",
+        reason: "The object's storage key, `<org>/<user>/<session>`-shaped and constrained to the org's prefix. Reads and versioned deletes resolve it by equality."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_pointers",
+        column: "version_id",
+        category: "structural",
+        reason: "The S3 version id a versioned delete targets. An opaque storage identifier."
+      },
+      // ── incident_signals agent columns: provenance and pointers, not content ──
+      //
+      // proposed_fields is NOT here — it can carry working_theory / root_cause
+      // prose and is registered as an encrypted column. These four cannot.
+      {
+        database: "haansi_intelligence_prod",
+        table: "incident_signals",
+        column: "origin",
+        category: "structural",
+        reason: "A two-value vocabulary term ('system' | 'agent') that the server sets from the credential and every read filters on. Encrypting it would make the agent-proposal index unusable and hide provenance from the people it exists to inform."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "incident_signals",
+        column: "agent_id",
+        category: "operational",
+        reason: "Which workload made a claim, derived by us from the credential \u2014 'credential:cli', 'user:<uuid>'. It names a caller of ours, not anything a customer wrote, and it is what an operator groups by when a particular agent starts proposing badly."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "incident_signals",
+        column: "citations",
+        category: "join-key",
+        reason: "Typed references \u2014 {ref_type, ref_id} \u2014 to process_activity_facts rows in the same incident, validated server-side before the row is written. Pointers to content, never content; the rows they point at carry their own encryption."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "incident_signals",
+        column: "producer",
+        category: "not-personal",
+        reason: "What produced a claim: model name, prompt version. Ours, not the customer's, and kept readable so a proposal that ages badly can be traced to the model that made it."
+      },
+      // ── incident_idempotency: request bookkeeping, never content ──
+      //
+      // The table records THAT a mutation already ran, keyed by
+      // (organization_id, endpoint, idempotency_key). It deliberately stores no
+      // response body — only the revision the mutation produced — because the
+      // response would have been an incident overlay carrying root_cause and
+      // resolution_summary, both registered encrypted columns, and a copy here
+      // would be their plaintext sitting beside their own ciphertext. That design
+      // choice is what makes these two columns safe to leave clear.
+      {
+        database: "haansi_intelligence_prod",
+        table: "incident_idempotency",
+        column: "endpoint",
+        category: "operational",
+        reason: "Our own route label \u2014 'declare', 'dismiss', 'patch'. Names a thing we wrote, not anything a customer did, and it is half of the UNIQUE constraint that makes a replay detectable: encrypting it destroys the conflict target and the same key would be accepted twice."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "incident_idempotency",
+        column: "process_id",
+        category: "join-key",
+        reason: "The mined workstream's process_id \u2014 the same internal join key the incident overlay, signal and audit tables carry in the clear, kept here so a replay can read the overlay back without a second lookup. An identifier we generate, not anything a customer wrote."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "incident_idempotency",
+        column: "idempotency_key",
+        category: "join-key",
+        reason: "An opaque client-generated token, matched by equality on every write as the other half of the UNIQUE constraint. Randomized encryption makes two copies of one key unequal, which turns every retry into a second apply \u2014 the exact failure the table exists to prevent."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_messages",
+        column: "rating_reasons",
+        category: "operational",
+        reason: "A server-validated five-code enum used by ARRAY DISTINCT/ORDER BY and platform-mining GROUP BY counts. Randomized encryption makes equal codes unequal and silently corrupts both aggregates; free-text feedback belongs in the separately encrypted rating_comment column."
+      },
+      // ── redaction_claims: a work queue that holds references, never content ──
+      //
+      // Same shape as embedding_claims below. The queue records WHICH staging
+      // object needs redacting and WHO holds the lease; the session text itself is
+      // fetched from object storage at claim time, redacted, and written to the
+      // clean bucket. No session content is ever stored in a row here — that is
+      // the property the whole design depends on, and it is why these four are
+      // exclusions rather than a tier.
+      {
+        database: "haansi_prod",
+        table: "redaction_claims",
+        column: "staging_path",
+        category: "join-key",
+        reason: "The object key \u2014 org/user/session.jsonl. Part of the UNIQUE constraint that makes enqueue idempotent, so it is matched by equality on every insert; encrypting it destroys the conflict target and the queue would accept duplicate claims for one object. The identifiers it embeds are already columns on this table."
+      },
+      {
+        database: "haansi_prod",
+        table: "redaction_claims",
+        column: "staging_token",
+        category: "join-key",
+        reason: "Identifies WHICH VERSION of the object this claim is for \u2014 the object's x-haansi-uploaded-at. The other half of the same UNIQUE constraint, matched by equality for the same reason. A timestamp, not personal data."
+      },
+      {
+        database: "haansi_prod",
+        table: "redaction_claims",
+        column: "owner",
+        category: "operational",
+        reason: "Which WORKER holds the lease \u2014 hostname:pid. Names a process, not a person, and is compared by equality in the guarded write-back so a worker cannot complete another's claim. Encrypting it breaks that guard."
+      },
+      {
+        database: "haansi_prod",
+        table: "redaction_claims",
+        column: "last_error",
+        category: "operational",
+        reason: "Operator diagnostics: why a claim was requeued or parked \u2014 a Presidio timeout, an object-store refusal. Truncated to 2000 characters at the write. It must never carry session TEXT, and does not: the worker records the exception message, never the content it was redacting. Encrypting it would make it unreadable in exactly the situation it exists for, which is someone asking why redaction stopped."
+      },
+      // ── embedding_claims: a work queue that holds references, never content ──
+      //
+      // The three text columns below exist because the leased embedding worker
+      // needs to know WHICH row to embed and WHO holds the lease. The text to
+      // embed is fetched from the target row at claim time and the vector written
+      // straight back, so no customer content ever rests in this table.
+      {
+        database: "haansi_intelligence_prod",
+        table: "embedding_claims",
+        column: "source_table",
+        category: "operational",
+        reason: "A table NAME from the checked-in EMBEDDING_TABLES registry \u2014 one of six fixed values, never user input. Encrypting it would break the worker's own routing, since it dispatches on this column."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "embedding_claims",
+        column: "owner",
+        category: "operational",
+        reason: "Identifies the WORKER holding the lease (hostname:pid), not a person. It is compared for equality on every write-back \u2014 the guard that stops a worker whose lease expired mid-inference overwriting the worker that took over \u2014 so it must remain matchable."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "embedding_claims",
+        column: "last_error",
+        category: "operational",
+        reason: "A database or embedder error message, truncated to 2000 chars. It records why a claim failed (connection refused, embedder timeout), not the content being embedded \u2014 the worker fails BEFORE it holds any customer text, and the text is never part of the message. Kept readable because its only purpose is an operator diagnosing a stuck queue."
+      },
+      // ── source_events / sync_state / schema_migrations, classified 2026-09-13 ──
+      // These arrived with the unified-integrations work and reached main
+      // unclassified, which is what the ratchet caught.
+      {
+        database: "haansi_integrations_prod",
+        table: "source_events",
+        column: "normalize_error",
+        category: "blocked",
+        reason: "Should be encrypted, and is not. Unlike embedding_claims.last_error \u2014 which records a failure that happens BEFORE the worker holds any customer text \u2014 this is written from inside the normalizer while it is parsing raw_payload (normalization.ts markSourceEventNormalizeError, called with error.message from an arbitrary throw). A parse or validation error can quote the fragment it choked on, and that fragment is customer content. The predicates that read it are NULL checks, which survive encryption, so registering it is feasible \u2014 it needs the encryption job to sweep the existing plaintext rows, which is a backfill rather than a classification."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_events",
+        column: "object_type",
+        category: "structural",
+        reason: "Names the shape of the captured object (message, issue, pull_request). The normalizer dispatches on it and it is part of the uniqueness key, so it must stay readable; it is a vocabulary term, not content."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "sync_state",
+        column: "object_type",
+        category: "structural",
+        reason: "The same vocabulary term as source_events.object_type, keying the per-(platform, object_type) watermark. Encrypting it would make the cursor unreadable to the reader that must find it by that key."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_events",
+        column: "source_object_id",
+        category: "join-key",
+        reason: "The provider's own identifier for the object (a Slack ts, a GitHub node id). It is how a captured row is matched back to its source and de-duplicated across re-captures; encrypting it would break that equality. Pseudonymous by construction \u2014 it identifies an object, not a person."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_events",
+        column: "source_event_key",
+        category: "join-key",
+        reason: "The idempotency key a capture writes under, and the column the uniqueness constraint is built on. Equality here is what stops a replayed tap run from duplicating the corpus; an encrypted value with a random IV compares unequal to itself."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_events",
+        column: "ingest_mode",
+        category: "operational",
+        reason: "How the row arrived \u2014 tap, webhook, backfill. Read by the replay and catch-up paths to decide what may be re-processed. A closed vocabulary with no customer content."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_events",
+        column: "cursor_token",
+        category: "operational",
+        reason: "The provider watermark the row was captured at, in the same class as sync_state.cursor_value: opaque control-plane state that the resume path must read to avoid restarting a sync. Not source content."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_events",
+        column: "simulation_run_id",
+        category: "not-personal",
+        reason: "Tags a row as belonging to a simulation run so production reads can exclude it. Generated by us, never derived from the source."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "schema_migrations",
+        column: "git_sha",
+        category: "operational",
+        reason: "The commit a migration was applied from \u2014 SOC 2 CC8.1 audit-trail evidence about our own deploys. Carries no tenant data, and must stay readable to be evidence at all."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "schema_migrations",
+        column: "notes",
+        category: "operational",
+        reason: "Operator annotation on a ledger row (why a CONCURRENTLY migration was applied outside a transaction, that a row was backfill-stamped). Written by us about our own schema changes, not by or about a tenant."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_accounts",
+        column: "display_name",
+        category: "blocked",
+        reason: 'Personal data that should be encrypted, and is not. source_accounts has a COMPOSITE primary key (organization_id, source_platform, source_account_id) and no `id` column, while the encryption job addresses rows as `WHERE "<primaryKey>" = $1` \u2014 a single column. It was previously registered with primaryKey "id", which does not exist, so the job aborted when it reached this table. Pointing it at source_account_id instead would be worse than the crash: that column is not unique on its own, so one organization\'s UPDATE would rewrite another\'s row. Needs composite-key support in the job.'
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_charts",
+        column: "engine",
+        category: "structural",
+        reason: "Which renderer draws the saved chart ('vega-lite'), CHECK-constrained. The reader dispatches on it; a code vocabulary term, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "qna_charts",
+        column: "tool_auth_scope",
+        category: "operational",
+        reason: "The access rule the chart's data was produced under ('org', 'permission:experts:read'), re-checked on every read. A code-authored policy name the read path must evaluate; no customer content."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "capture_scan_ledger",
+        column: "stream",
+        category: "structural",
+        reason: "The tap/poller stream name a scan covered (messages, issues). A fixed vocabulary the coverage reader filters on; no customer content."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "capture_scan_ledger",
+        column: "scope",
+        category: "operational",
+        reason: 'A fixed, code-authored description of what a scan covered ("every channel the app has joined"), taken from SCAN_PROOFS. Never customer content.'
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "capture_scan_ledger",
+        column: "failure_reason",
+        category: "operational",
+        reason: "Why a capture scan stopped (a provider error class or our own message). Control-plane diagnostics for our runs, read by operators; it carries no captured content."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "sync_state",
+        column: "cursor_type",
+        category: "operational",
+        reason: "Names the cursor protocol, such as timestamp or page_token. The sync reader dispatches on it and it contains no customer content; encrypting it would prevent the ingestion worker from interpreting cursor_value."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "sync_state",
+        column: "cursor_value",
+        category: "operational",
+        reason: "An opaque provider watermark used to resume incremental ingestion. It is control-plane state rather than source content and must remain readable by the raw cursor upsert/read path to avoid restarting syncs."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_accounts",
+        column: "account_type",
+        category: "operational",
+        reason: "A fixed routing enum (user_oauth, org_oauth, or service_account), not a person attribute. Ingestion uses it to choose the account flow, so encrypting it would break control-plane dispatch predicates."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "source_accounts",
+        column: "metadata",
+        category: "blocked",
+        reason: "Provider metadata may contain tenant data and should be encrypted, but source_accounts has a composite primary key while the conversion job supports only one primary-key column. It shares display_name's blocker."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "google_workspace_service_accounts",
+        column: "key_json_encrypted",
+        category: "structural",
+        reason: "The service-account private key is already encrypted by the owning Google Workspace credential helper. Registering it for transparent encryption would double-wrap it and break the explicit decrypt reader."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "google_workspace_service_accounts",
+        column: "domain",
+        category: "not-personal",
+        reason: "The customer's Workspace domain identifies an organization rather than an individual and is required as routing configuration for delegated Google API calls. Individual administrator email is encrypted separately."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "google_workspace_service_accounts",
+        column: "delegated_scopes",
+        category: "operational",
+        reason: "A list of fixed Google OAuth permission names selected for delegation. It contains configuration rather than subject data and must remain readable when constructing the delegated credential."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "google_workspace_service_accounts",
+        column: "discovery_status",
+        category: "operational",
+        reason: "A bounded workflow-state value such as pending or completed. Operators and discovery code filter on it; it carries no customer content and encrypting it would break those status predicates."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "google_workspace_service_accounts",
+        column: "discovery_error",
+        category: "blocked",
+        reason: "A Google API error can repeat a tenant email or domain and should be encrypted, but updateDiscoveryStatus writes through a raw pool without organization context. Move that writer through the doorway before tiering it."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "github_path_token_stats",
+        column: "common_tokens",
+        category: "derived",
+        reason: "A derived set of high-frequency repository path tokens used for exact membership filtering during graph edge building. Encrypting the derived lookup set would make its token comparisons unusable."
+      },
+      {
+        database: "haansi_prod",
+        table: "platform_admin_access_log",
+        column: "actor_email",
+        category: "audit-actor",
+        reason: "HAANSI staff, not a data subject. This log exists to prove WHO reached a customer's data; encrypting the actor defeats the control and the SOC 2 evidence it produces. The same address in organization_users IS encrypted \u2014 the distinction is the role the row plays, which no name-based rule can see."
+      },
+      {
+        database: "haansi_prod",
+        table: "machine_credential_audit_log",
+        column: "actor_email",
+        category: "audit-actor",
+        reason: "Same as platform_admin_access_log.actor_email \u2014 audit trail actor."
+      },
+      {
+        database: "haansi_prod",
+        table: "waitlist_activity_log",
+        column: "actor_email",
+        category: "audit-actor",
+        reason: "Same as platform_admin_access_log.actor_email \u2014 audit trail actor."
+      },
+      {
+        database: "haansi_prod",
+        table: "organizations",
+        column: "name",
+        category: "not-personal",
+        reason: "The organisation's own name, which the product renders on every page and every admin surface. A company name is not personal data; for a one-person org it can be identifying, which is accepted here because encrypting it would blind the platform to its own tenants."
+      },
+      // Residency control plane (migration byod-residency/001). Recorded here the
+      // moment the columns were added, which is the same gate doing the same job as
+      // it did for the per-org key columns below.
+      //
+      // These are ROUTING STATE, not tenant content: closed unions enforced by CHECK
+      // constraints, read on the resolution path of every tenant request to decide
+      // which database answers it. Encrypting them would be self-defeating in the
+      // literal sense — the resolver would have to decrypt a value in order to learn
+      // where the decryption key's data lives. Same reasoning that kept
+      // qna_messages.rating_reasons out: a value the database itself must compare
+      // cannot be randomised ciphertext.
+      {
+        database: "haansi_prod",
+        table: "organizations",
+        column: "authoritative_residency",
+        category: "not-personal",
+        reason: "Which database is authoritative for this org's tenant content: 'platform' or 'byod', enforced by a CHECK constraint. Operational routing state, read before every tenant query, and not derived from customer data."
+      },
+      {
+        database: "haansi_prod",
+        table: "organizations",
+        column: "migration_phase",
+        category: "not-personal",
+        reason: "Which residency migration step is in progress, from a closed set enforced by a CHECK constraint. Says nothing about the org beyond the fact that an operator started a migration, and the write fence compares it on the admission path."
+      },
+      // The per-org key columns themselves (migration encryption/005). Recorded
+      // the moment they were added, because the Phase 0 gate demanded it — which
+      // is the gate doing its job on the very next schema change.
+      {
+        database: "haansi_prod",
+        table: "organizations",
+        column: "encryption_key_id",
+        category: "structural",
+        reason: "Names which key encrypted this org's data (e.g. org:<uuid>:v1). It is the LABEL on the key, not personal data, and the resolver reads it to decide which key to unwrap \u2014 encrypting it would make the ciphertext undecryptable by the very lookup that needs it."
+      },
+      {
+        database: "haansi_prod",
+        table: "organizations",
+        column: "encryption_key_wrapped",
+        category: "structural",
+        reason: "The org's DEK, already encrypted \u2014 by KMS, under the CMK. Encrypting it again with a key derived FROM it is circular. At rest it is an opaque blob useless without kms:Decrypt, which is the whole reason it can live in Postgres rather than as per-org Secrets Manager sprawl."
+      },
+      {
+        database: "haansi_prod",
+        table: "organizations",
+        column: "encryption_previous_keys",
+        category: "structural",
+        reason: "Retired DEKs as {keyId: KMS-wrapped DEK}. Same argument as encryption_key_wrapped, one generation back: already encrypted under the CMK, and encrypting it with a key derived from itself is circular. Kept so ciphertext written before a rotation stays readable \u2014 and kept on this row so the deletion tick's crypto-shred destroys every generation in one statement."
+      },
+      {
+        database: "haansi_prod",
+        table: "organizations",
+        column: "encryption_cmk_id",
+        category: "structural",
+        reason: "A KMS key ARN \u2014 infrastructure identity, not personal data. Needed in plaintext to know which CMK can unwrap this org's DEK, which matters the moment a BYOK org brings its own."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "person_source_identities",
+        column: "native_user_id",
+        category: "join-key",
+        reason: "The platform-assigned user id (GitHub numeric id, Slack U\u2026, Atlassian accountId) that makes a native identity unique and lets a reintegration find the same row again. Pseudonymous, never an email: email-only identities leave it NULL and use the encrypted email + email_blind."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "activity_participants",
+        column: "role",
+        category: "operational",
+        reason: "A seven-value CHECK-constrained enum (author, reviewer, \u2026) that the contribution model weights and filters on. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "process_activity_facts",
+        column: "event_verb",
+        category: "operational",
+        reason: "A nine-value CHECK-constrained enum (created, commented, reviewed, \u2026) copied from the canonical activity. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "organization_mining_config",
+        column: "heuristic_calibration",
+        category: "derived",
+        reason: "Calibrated heuristic thresholds (object-graph/122): three score cuts, the percentiles and sample size they came from, and a timestamp. Numbers computed from score distributions; no content or personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "organization_mining_config",
+        column: "rerun_hold_reason",
+        category: "operational",
+        reason: "Why a hard-reset re-run stopped midway (object-graph/123): a service error message such as 'Replay cancelled (service shutting down)', shown to operators. No content or personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "process_activity_facts",
+        column: "evidence_fingerprint",
+        category: "derived",
+        reason: "A sha256 hex digest of the event's sorted (role, object id) pairs, stamped by the extractor and compared by equality to tell whether an event's inputs changed. One-way over opaque ids; no content or personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_dirty_queue",
+        column: "scope",
+        category: "operational",
+        reason: "A five-value CHECK-constrained enum naming what kind of thing is dirty. Part of the coalescing primary key; no personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_dirty_queue",
+        column: "scope_id",
+        category: "join-key",
+        reason: "The UUID (as text) of the dirty person object, identity group, source identity or member, or '' for a whole org. Part of the coalescing primary key, matched by equality on every enqueue."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_dirty_queue",
+        column: "reasons",
+        category: "operational",
+        reason: "Fixed trigger reason codes (participants_insert, activity_update, \u2026) unioned with DISTINCT on coalesce. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_dirty_queue",
+        column: "lease_owner",
+        category: "operational",
+        reason: "The worker id holding the processing lease. Infrastructure identity, compared by equality on acknowledgement."
+      },
+      {
+        database: "haansi_prod",
+        table: "expert_member_outbox",
+        column: "change",
+        category: "operational",
+        reason: "A three-value CHECK-constrained enum (insert, update, delete). No personal data."
+      },
+      // ── mining_pending_decisions (object-graph/113): ids, codes and error strings ──
+      {
+        database: "haansi_intelligence_prod",
+        table: "mining_pending_decisions",
+        column: "reason",
+        category: "operational",
+        reason: "A six-value CHECK-constrained code for why the activity is pending (awaiting_llm, llm_empty, \u2026). No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "mining_pending_decisions",
+        column: "last_error",
+        category: "operational",
+        reason: "The error class and message of the failed LLM attempt, truncated. Writers pass error text, never model output or event content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "mining_pending_decisions",
+        column: "rejected_reference",
+        category: "operational",
+        reason: "The process id or activity id the rejected decision named, echoed into the retry prompt. An identifier, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "mining_pending_decisions",
+        column: "candidate_process_ids",
+        category: "join-key",
+        reason: "Process ids the scorer offered for this activity; the decision is validated against this set by equality."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "mining_pending_decisions",
+        column: "heuristic",
+        category: "derived",
+        reason: "Scorer output for the activity: numeric scores keyed by candidate process id. Derived from the evidence graph, carries no content."
+      },
+      // ── process_state_history (object-graph/114): ids, codes, the category ──
+      {
+        database: "haansi_intelligence_prod",
+        table: "process_state_history",
+        column: "process_id",
+        category: "join-key",
+        reason: "The mined process's process_id \u2014 the internal join key to process_registry (composite FK). An identifier we generate."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "process_state_history",
+        column: "curation_state",
+        category: "operational",
+        reason: "A five-value CHECK-constrained curation code copied from process_registry.curation_state. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "process_state_history",
+        column: "category",
+        category: "derived",
+        reason: "The process's taxonomy category at that point, copied from process_registry.category, which is stored in the clear and read by equality. A label the classifier or a curator picked, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "process_state_history",
+        column: "merged_into",
+        category: "join-key",
+        reason: "The process_id this process was merged into \u2014 a process_registry join key the as-of read follows by equality."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "process_state_history",
+        column: "actor_kind",
+        category: "operational",
+        reason: "A three-value CHECK-constrained code (user, system, model). The user, when there is one, is actor_user_id (a uuid)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "process_state_history",
+        column: "source_command",
+        category: "operational",
+        reason: "The typed command that wrote the row (merge, curation, \u2026), a CHECK-constrained lowercase identifier. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "identity_disputes",
+        column: "link_source",
+        category: "operational",
+        reason: "A two-value CHECK-constrained enum (manual, email_blind). No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "identity_disputes",
+        column: "status",
+        category: "operational",
+        reason: "A four-value CHECK-constrained dispute state. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "identity_disputes",
+        column: "resolution",
+        category: "operational",
+        reason: "A CHECK-constrained resolution code. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "member_identity_links",
+        column: "link_source",
+        category: "operational",
+        reason: "A two-value CHECK-constrained enum (manual, email_blind). No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "member_identity_links",
+        column: "state",
+        category: "operational",
+        reason: "A four-value CHECK-constrained link state. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "member_identity_links",
+        column: "conflict_reason",
+        category: "operational",
+        reason: "A CHECK-constrained reason code. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_facts",
+        column: "platform_breakdown",
+        category: "derived",
+        reason: "Counts and scores per platform and entity type. Numbers and enum labels only \u2014 no names or content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_facts",
+        column: "role_breakdown",
+        category: "derived",
+        reason: "Counts per participant role enum. No personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_facts",
+        column: "top_workstreams",
+        category: "derived",
+        reason: "Process ids with counts, scores and timestamps. Names are joined at read time from process_registry, so no plaintext name is copied here."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_facts",
+        column: "collaborators",
+        category: "derived",
+        reason: "Organization-user ids with shared-activity counts. Names are joined at read time from organization_users."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_facts",
+        column: "recent_activities",
+        category: "derived",
+        reason: "Activity ids, target object ids, role and verb enums, and timestamps for the profile feed. Titles are read from objects at request time, so no content or name is copied here."
+      },
+      // Digest delivery (migrations/digests-platform/001). Schedules, delivery
+      // state and inbox references only; digest text stays in the encrypted
+      // entry and is never copied here.
+      {
+        database: "haansi_prod",
+        table: "digest_subscriptions",
+        column: "scope",
+        category: "operational",
+        reason: "A two-value CHECK-constrained enum: member or org."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_subscriptions",
+        column: "recipe",
+        category: "operational",
+        reason: "The prompt recipe key, a fixed code-defined string."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_subscriptions",
+        column: "cadence",
+        category: "operational",
+        reason: "A CHECK-constrained enum naming the schedule length."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_subscriptions",
+        column: "timezone",
+        category: "operational",
+        reason: "An IANA timezone name the schedule runs in."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_subscriptions",
+        column: "channels",
+        category: "operational",
+        reason: "CHECK-constrained channel names (email, slack_dm)."
+      },
+      // Teams (migrations/digests-platform/004): admin-entered labels for how
+      // the organization groups its people, shown to its own members. Not
+      // customer content drawn from integrations.
+      // Work logs (migrations/digests/004): `text` is encrypted (column
+      // registry); these two are machine values.
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_work_logs",
+        column: "workstream_id",
+        category: "operational",
+        reason: "A process_registry id the author tagged the entry with."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_work_logs",
+        column: "source",
+        category: "operational",
+        reason: "A CHECK-constrained enum: web, cli, slack or mcp."
+      },
+      {
+        database: "haansi_prod",
+        table: "teams",
+        column: "name",
+        category: "operational",
+        reason: "An admin-entered team label (e.g. Payments), shown to the org's own members."
+      },
+      {
+        database: "haansi_prod",
+        table: "teams",
+        column: "description",
+        category: "operational",
+        reason: "An admin-entered one-line description of a team, shown to the org's own members."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_org_policies",
+        column: "org_timezone",
+        category: "operational",
+        reason: "An IANA timezone name the org digest's weeks are in."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_org_policies",
+        column: "allowed_channels",
+        category: "operational",
+        reason: "CHECK-constrained channel names (email, slack_dm)."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_deliveries",
+        column: "timezone",
+        category: "operational",
+        reason: "An IANA timezone name the week was computed in."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_deliveries",
+        column: "channel",
+        category: "operational",
+        reason: "A CHECK-constrained enum naming the delivery channel."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_deliveries",
+        column: "status",
+        category: "operational",
+        reason: "A CHECK-constrained enum of delivery state."
+      },
+      {
+        database: "haansi_prod",
+        table: "digest_deliveries",
+        column: "reason",
+        category: "operational",
+        reason: "A short code such as quiet or no_slack_identity, never an error message."
+      },
+      {
+        database: "haansi_prod",
+        table: "user_notifications",
+        column: "kind",
+        category: "operational",
+        reason: "A CHECK-constrained enum naming the notification type."
+      },
+      {
+        database: "haansi_prod",
+        table: "user_notifications",
+        column: "ref_id",
+        category: "join-key",
+        reason: "The id of the thing the notification points at, e.g. a digest entry UUID."
+      },
+      {
+        database: "haansi_prod",
+        table: "user_notifications",
+        column: "data",
+        category: "structural",
+        reason: "Non-sensitive display fields only (period dates, status); content stays in the referenced record."
+      },
+      // Digests (migrations/digests/002). Queue state, citation ids and the
+      // access log carry no content: the entry's text lives in knowledge_artifacts,
+      // whose columns are already encrypted.
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_generation_queue",
+        column: "digest_scope",
+        category: "operational",
+        reason: "A two-value CHECK-constrained enum: member or org."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_generation_queue",
+        column: "period_kind",
+        category: "operational",
+        reason: "A CHECK-constrained enum naming the period length."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_generation_queue",
+        column: "timezone",
+        category: "operational",
+        reason: "An IANA timezone name the week is computed in."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_generation_queue",
+        column: "recipe",
+        category: "operational",
+        reason: "The prompt recipe key, a fixed code-defined string."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_generation_queue",
+        column: "reason",
+        category: "operational",
+        reason: "A three-value CHECK-constrained enum: scheduled, on_demand or regenerate."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_generation_queue",
+        column: "status",
+        category: "operational",
+        reason: "A four-value CHECK-constrained enum of queue state."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_generation_queue",
+        column: "lease_owner",
+        category: "operational",
+        reason: "The worker's host and process id holding the lease."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_generation_queue",
+        column: "error_code",
+        category: "operational",
+        reason: "A short code such as generation_error, never an error message."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "onboarding_guides",
+        column: "status",
+        category: "operational",
+        reason: "A CHECK-constrained lifecycle enum (draft, published, unpublished, deleted) that decides who may see the guide; read by SQL predicates."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "onboarding_guides",
+        column: "template_id",
+        category: "operational",
+        reason: "The id of a builtin report template (e.g. workstream-handoff), never user text."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "onboarding_guides",
+        column: "audience",
+        category: "operational",
+        reason: "A short audience code (engineer, business, agent) chosen from a fixed list."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "onboarding_guide_source_refs",
+        column: "ref_type",
+        category: "operational",
+        reason: "A CHECK-constrained enum naming the kind of cited source."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "onboarding_guide_source_refs",
+        column: "ref_id",
+        category: "join-key",
+        reason: "The id of the cited workstream, incident, solution, artifact, object or guide \u2014 a UUID or a process id, matched by equality."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "onboarding_guide_source_refs",
+        column: "state",
+        category: "operational",
+        reason: "A CHECK-constrained enum (live, revoked)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_evidence_refs",
+        column: "evidence_key",
+        category: "structural",
+        reason: "The E-key (E1, E2, \u2026) the entry cites."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_evidence_refs",
+        column: "ref_type",
+        category: "operational",
+        reason: "A CHECK-constrained enum naming the kind of cited source."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_evidence_refs",
+        column: "ref_id",
+        category: "join-key",
+        reason: "The id of the cited activity, workstream, artifact or incident \u2014 a UUID or a process id, matched by equality."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_access_log",
+        column: "action",
+        category: "operational",
+        reason: "A CHECK-constrained enum naming what the actor did."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "digest_access_log",
+        column: "surface",
+        category: "operational",
+        reason: "The product surface of the request (web, cli, mcp), taken from the credential."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_evidence_refs",
+        column: "source_type",
+        category: "operational",
+        reason: "A four-value CHECK-constrained enum naming the kind of cited source."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_evidence_refs",
+        column: "source_id",
+        category: "join-key",
+        reason: "The id of the cited activity, object, workstream or artifact \u2014 a UUID or a process id, matched by equality when a source is deleted."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profiles",
+        column: "model",
+        category: "operational",
+        reason: "The model id that generated the version. Configuration, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profiles",
+        column: "prompt_version",
+        category: "operational",
+        reason: "A prompt revision label. Configuration, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profiles",
+        column: "input_hash",
+        category: "derived",
+        reason: "SHA-256 of the evidence pack, compared by equality to skip an unchanged regeneration. A digest, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_areas",
+        column: "horizon",
+        category: "operational",
+        reason: "A two-value CHECK-constrained enum (established, current)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_areas",
+        column: "depth",
+        category: "operational",
+        reason: "A three-value CHECK-constrained enum (owner, contributor, familiar)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_areas",
+        column: "confidence",
+        category: "operational",
+        reason: "A three-value CHECK-constrained enum (high, medium, low)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profiles",
+        column: "validation_drops",
+        category: "derived",
+        reason: "object-graph/102. Integer counts of what the profile validator rejected, keyed by reason (area_work_shaped, uncited_claim, \u2026). Numbers only \u2014 none of the rejected text is kept, which is the whole point: the counts exist so a thin profile can be explained without storing what the model wrote about a person."
+      },
+      // Org-level expertise grouping (object-graph/100). The pass's lease and its
+      // audit log; the only content-bearing columns on either table are the area
+      // names, which are classified in column-registry.ts.
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_grouping_state",
+        column: "claimed_by",
+        category: "operational",
+        reason: "The pipeline worker id holding the org's grouping lease. Infrastructure identity, never content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_grouping_state",
+        column: "last_input_hash",
+        category: "derived",
+        reason: "A SHA-256 digest of the vocabulary the last run saw, used to skip an unchanged org. One-way and carries no names."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_area_merge_log",
+        column: "action",
+        category: "operational",
+        reason: "A three-value CHECK-constrained enum (merge, rename, describe)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_area_merge_log",
+        column: "model",
+        category: "operational",
+        reason: "The provider model id that produced the grouping, for attributing a bad run. Vendor identifier, never content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_citations",
+        column: "contribution",
+        category: "derived",
+        reason: "What the member contributed to one cited source: two counts and two dates (object-graph/128). No titles, names or text."
+      },
+      // Trending topics (trending-clustering/001, 002). A topic is stored as ids:
+      // which item is its centre and which items belong to it. Titles are read
+      // from the items themselves (knowledge_artifacts.title,
+      // process_registry.name — both encrypted), never copied here.
+      {
+        database: "haansi_intelligence_prod",
+        table: "artifact_clusters",
+        column: "theme",
+        category: "derived",
+        reason: "Always the empty string. It once held a copy of the centre's title; the trending tick now writes it empty and the API reads the title from the item. Kept only because the column is NOT NULL."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "artifact_clusters",
+        column: "theme_kind",
+        category: "operational",
+        reason: "Enum: 'artifact' or 'workstream' \u2014 which kind of item is the topic's centre. Never content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "artifact_clusters",
+        column: "theme_process_id",
+        category: "derived",
+        reason: "The process id of the workstream at a topic's centre. An opaque identifier into process_registry; its name stays there, encrypted."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "artifact_cluster_workstreams",
+        column: "process_id",
+        category: "derived",
+        reason: "The process id of a workstream that belongs to a topic. An opaque identifier into process_registry; no name or text."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "org_expertise_areas",
+        column: "curated_at",
+        category: "operational",
+        reason: "Manual edit marker used by grouping and description writers."
+      },
+      // Cited expertise-area descriptions (object-graph/129). The description
+      // text itself is org_expertise_areas.description, which is encrypted.
+      {
+        database: "haansi_intelligence_prod",
+        table: "org_expertise_areas",
+        column: "description_citations",
+        category: "derived",
+        reason: "Per sentence of the description, the sources it cites, as '<source_type>:<source_id>' keys. Ids only \u2014 no titles, names or text."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "org_expertise_areas",
+        column: "description_input_hash",
+        category: "derived",
+        reason: "SHA-256 of the evidence the description was written from, compared by equality to skip an unchanged area. One-way; carries no content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "org_expertise_areas",
+        column: "description_model",
+        category: "operational",
+        reason: "The provider model id that wrote the description. Vendor identifier, never content."
+      },
+      // Expert profile scheduling (object-graph/127).
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_load_cycle_state",
+        column: "hold_reason",
+        category: "operational",
+        reason: "A four-value CHECK-constrained enum naming why profile generation is held (initial_sync_pending, normalization_lag, mining_lag, settling)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_facts",
+        column: "synthesis_check_outcome",
+        category: "operational",
+        reason: "The synthesis pass's outcome code for the member's last evidence check (written, unchanged, no_evidence, rejected_*, failed). A fixed set of pipeline codes, never content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_facts",
+        column: "synthesis_check_hash",
+        category: "derived",
+        reason: "SHA-256 of the evidence pack seen at the last check, the same digest as expert_profiles.input_hash. One-way; carries no content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_synthesis_claims",
+        column: "claimed_by",
+        category: "operational",
+        reason: "The pipeline worker id holding the synthesis lease. Infrastructure identity, never content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_synthesis_claims",
+        column: "pending_input",
+        category: "derived",
+        reason: "A parked batch member's citation map: evidence keys (E1\u2026) mapped to source type, source id, integration platform and account key, plus an activity count, an input digest and a prompt version. No titles, names or summaries \u2014 the prompt text is never persisted (citationsOf strips it). Deleted when the attempt ends."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_curation",
+        column: "hidden_platforms",
+        category: "operational",
+        reason: "Integration type names (github, slack, \u2026) whose evidence the member hid. A closed vocabulary, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_curation_log",
+        column: "changed_fields",
+        category: "operational",
+        reason: "Names of the curation fields an edit changed (headline, pinned areas, \u2026). Field names, never their values."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_curation_log",
+        column: "before_hash",
+        category: "derived",
+        reason: "SHA-256 of the overlay before the edit, for audit comparison. A digest, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "expert_profile_curation_log",
+        column: "after_hash",
+        category: "derived",
+        reason: "SHA-256 of the overlay after the edit, for audit comparison. A digest, not content."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "objects",
+        column: "canonical_id",
+        category: "structural",
+        reason: "The object graph's identity key \u2014 identity resolution and the merge path match on it, and object_relationships/event_object_links join through the row it identifies. Often an email address, so this is a KNOWN accepted disclosure, recorded rather than hidden: encrypting it non-deterministically breaks entity resolution, and deterministically leaks by frequency while breaking nothing an attacker relies on."
+      },
+      {
+        database: "haansi_prod",
+        table: "byod_migration_jobs",
+        column: "operation",
+        category: "operational",
+        reason: "A closed enum of migration verbs, pinned by byod_migration_jobs_operation_check ('activate', 'disable', 'remove', 'enable_object_graph', 'disable_object_graph', 'retry'). It carries no tenant content, and the durable worker reads it to decide crash-safe finalization \u2014 encrypting a discriminator the recovery path compares against would make a half-finished migration unresumable."
+      },
+      // ── WS6 phase 2: session object attempts, revocations, erasure milestones ──
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "user_id",
+        category: "structural",
+        reason: "Identifier in the storage key layout, used to address and erase objects; the object bytes are encrypted under the per-attempt key."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "session_id",
+        category: "structural",
+        reason: "Identifier in the storage key layout, used to address and erase objects; the object bytes are encrypted under the per-attempt key."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "object_key",
+        category: "structural",
+        reason: "Identifier in the storage key layout, used to address and erase objects; the object bytes are encrypted under the per-attempt key."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "version_id",
+        category: "structural",
+        reason: "S3 version id returned by the store; addresses an object version for erasure."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "bucket_kind",
+        category: "operational",
+        reason: "Closed CHECK vocabulary the erasure and publication paths filter on."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "source_kind",
+        category: "operational",
+        reason: "Names the source whose generation the attempt was minted under; a vocabulary term, not content."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "status",
+        category: "operational",
+        reason: "Closed CHECK vocabulary the erasure and publication paths filter on."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "wrapped_key",
+        category: "derived",
+        reason: "Already ciphertext: the per-attempt data key wrapped by the org key."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_attempts",
+        column: "content_token",
+        category: "derived",
+        reason: "Staging token and redaction-manifest hash for idempotent re-publication; hashes and tokens, not content."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_revocations",
+        column: "scope_kind",
+        category: "operational",
+        reason: "Closed CHECK vocabulary the erasure and publication paths filter on."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_object_revocations",
+        column: "scope_id",
+        category: "structural",
+        reason: "User or session-source identifier a revocation applies to; erasure filters on it."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_erasure_records",
+        column: "user_id",
+        category: "structural",
+        reason: "Identifier of the erased user's scope; the milestone record must outlive the user's data to prove erasure."
+      },
+      {
+        database: "haansi_prod",
+        table: "session_erasure_records",
+        column: "reason",
+        category: "operational",
+        reason: "Closed CHECK vocabulary the erasure and publication paths filter on."
+      },
+      // Memory → Skills (skills/001).
+      {
+        database: "haansi_intelligence_prod",
+        table: "skills",
+        column: "approved_audience",
+        category: "operational",
+        reason: "Closed CHECK vocabulary (org, owner) the skill access check filters on."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "skill_publications",
+        column: "approved_audience",
+        category: "operational",
+        reason: "Closed CHECK vocabulary (org, owner) recorded per publish; read by the access check."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "skill_sources",
+        column: "source_kind",
+        category: "operational",
+        reason: "Closed CHECK vocabulary naming which table a dependency resolves against."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "skill_sources",
+        column: "content_fingerprint",
+        category: "derived",
+        reason: "sha256 of the captured source text, compared by equality to detect a changed source. Encrypting it would break the comparison; the text itself is not stored here."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "skill_candidates",
+        column: "lane",
+        category: "operational",
+        reason: "Closed CHECK vocabulary (recurring, single) the Suggested tab filters on."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "skill_candidates",
+        column: "audience_key",
+        category: "structural",
+        reason: "'shared' or a member's user id: which audience a group was formed within. An identifier, never text."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "skill_candidates",
+        column: "member_fingerprint",
+        category: "derived",
+        reason: "sha256 of the sorted member ids, compared by equality to detect a changed group."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "skill_events",
+        column: "channel",
+        category: "operational",
+        reason: "Closed CHECK vocabulary (mcp, qna, cli, web): where a skill was loaded from."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "skill_events",
+        column: "event",
+        category: "operational",
+        reason: "Closed CHECK vocabulary (loaded, resource_loaded, synced, applied, helped, not_helped)."
+      }
+    ];
   }
 });
 
@@ -22877,6 +25175,38 @@ var init_mining_config_fields = __esm({
   }
 });
 
+// ../../packages/@company/types/src/exchange.ts
+var EXCHANGE_DISCIPLINES, EXCHANGE_WORK_FUNCTIONS, EXCHANGE_DISCIPLINE_IDS, EXCHANGE_WORK_FUNCTION_IDS;
+var init_exchange = __esm({
+  "../../packages/@company/types/src/exchange.ts"() {
+    "use strict";
+    EXCHANGE_DISCIPLINES = [
+      { id: "engineering", label: "Engineering" },
+      { id: "data", label: "Data" },
+      { id: "design", label: "Design" },
+      { id: "product", label: "Product" },
+      { id: "security", label: "Security" },
+      { id: "operations", label: "Operations" },
+      { id: "go_to_market", label: "Go-to-market" },
+      { id: "people", label: "People" }
+    ];
+    EXCHANGE_WORK_FUNCTIONS = [
+      { id: "software_development", label: "Software development" },
+      { id: "infrastructure", label: "Infrastructure" },
+      { id: "incident_response", label: "Incident response" },
+      { id: "analytics", label: "Analytics" },
+      { id: "research", label: "Research" },
+      { id: "customer_success", label: "Customer success" },
+      { id: "sales", label: "Sales" },
+      { id: "marketing", label: "Marketing" },
+      { id: "finance", label: "Finance" },
+      { id: "legal", label: "Legal" }
+    ];
+    EXCHANGE_DISCIPLINE_IDS = EXCHANGE_DISCIPLINES.map((d) => d.id);
+    EXCHANGE_WORK_FUNCTION_IDS = EXCHANGE_WORK_FUNCTIONS.map((w) => w.id);
+  }
+});
+
 // ../../packages/@company/types/src/index.ts
 var init_src5 = __esm({
   "../../packages/@company/types/src/index.ts"() {
@@ -22889,6 +25219,7 @@ var init_src5 = __esm({
     init_query_dialect();
     init_report_template();
     init_mining_config_fields();
+    init_exchange();
   }
 });
 
@@ -24760,11 +27091,149 @@ var init_path_policy = __esm({
 });
 
 // ../../packages/@company/pii/src/deterministic.ts
+var RULES, DETERMINISTIC_ENTITY_TYPES;
 var init_deterministic = __esm({
   "../../packages/@company/pii/src/deterministic.ts"() {
     "use strict";
     init_spans();
     init_path_policy();
+    RULES = [
+      {
+        id: "PRIVATE_KEY",
+        entityType: "PRIVATE_KEY_BLOCK",
+        pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g,
+        replacement: "[REDACTED:PRIVATE_KEY]"
+      },
+      {
+        id: "JWT",
+        entityType: "JWT",
+        pattern: /eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+        replacement: "[REDACTED:JWT]"
+      },
+      {
+        id: "AWS_ACCESS_KEY",
+        entityType: "AWS_ACCESS_KEY",
+        pattern: /(?:^|[^A-Z0-9])(AKIA[0-9A-Z]{16})(?:[^A-Z0-9]|$)/gm,
+        capture: 1,
+        replacement: "[REDACTED:AWS_ACCESS_KEY]"
+      },
+      {
+        id: "AWS_SECRET_KEY",
+        entityType: "AWS_SECRET_KEY",
+        pattern: /(?:aws[_-]?secret[_-]?access[_-]?key|AWS_SECRET_ACCESS_KEY)\s*[=:]\s*["']?([A-Za-z0-9/+]{40})["']?/gi,
+        capture: 1,
+        replacement: "[REDACTED:AWS_SECRET_KEY]"
+      },
+      {
+        id: "API_KEY_ASSIGNMENT",
+        entityType: "API_KEY",
+        pattern: /(?:api[_-]?key|apikey|api[_-]?token|access[_-]?token|auth[_-]?token|bearer[_-]?token)\s*[=:]\s*["']?([A-Za-z0-9\-_.]{20,}?)["']?(?:\s|,|;|\n|$)/gi,
+        capture: 1,
+        replacement: "[REDACTED:API_KEY]"
+      },
+      {
+        id: "ANTHROPIC_KEY",
+        entityType: "ANTHROPIC_API_KEY",
+        pattern: /sk-ant-[A-Za-z0-9\-_]{32,}/g,
+        replacement: "[REDACTED:ANTHROPIC_KEY]"
+      },
+      {
+        id: "OPENAI_KEY",
+        entityType: "OPENAI_API_KEY",
+        pattern: /sk-(?:proj-)?[A-Za-z0-9]{20,}/g,
+        replacement: "[REDACTED:OPENAI_KEY]"
+      },
+      {
+        id: "GITHUB_TOKEN",
+        entityType: "GITHUB_TOKEN",
+        pattern: /(?:ghp_|ghs_|github_pat_)[A-Za-z0-9_]{36,}/g,
+        replacement: "[REDACTED:GITHUB_TOKEN]"
+      },
+      {
+        id: "SLACK_TOKEN",
+        entityType: "SLACK_TOKEN",
+        pattern: /xox[bpars]-[A-Za-z0-9\-]{16,}/g,
+        replacement: "[REDACTED:SLACK_TOKEN]"
+      },
+      {
+        id: "GCP_PRIVATE_KEY",
+        entityType: "GCP_PRIVATE_KEY",
+        pattern: /"private_key"\s*:\s*"(-----BEGIN[^"]+)"/g,
+        capture: 1,
+        replacement: "[REDACTED:GCP_PRIVATE_KEY]"
+      },
+      {
+        id: "DB_CONNECTION_STRING",
+        entityType: "DB_CONNECTION_STRING",
+        // The username may be EMPTY — `redis://:password@host` is the documented
+        // Redis form and leaked past `[^@\s]+:` because that requires one. amqp,
+        // amqps and rediss are the same shape and were simply missing from the
+        // scheme list.
+        pattern: /(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|rediss?|amqps?|clickhouse|mssql|mariadb):\/\/[^@\s]*:[^@\s]+@[^\s"']+/gi,
+        replacement: "[REDACTED:DB_CONNECTION_STRING]"
+      },
+      {
+        id: "SECRET_ASSIGNMENT",
+        entityType: "SECRET",
+        // QUOTED form. An unquoted assignment is a separate rule below: folding
+        // them into one alternation makes the quote handling ambiguous and risks
+        // the closing quote landing inside the captured value.
+        pattern: /["']?(?:password|passwd|secret|client[_-]?secret|private[_-]?key|encryption[_-]?key|api[_-]?secret|auth[_-]?token)["']?\s*[=:]\s*["']([^"'\s]{6,})["']/gi,
+        capture: 1,
+        replacement: "[REDACTED:SECRET]"
+      },
+      {
+        // UNQUOTED assignment: `DATABASE_PASSWORD=sup3rs3cret`, `PGPASSWORD=x`,
+        // `--password xyz`. This is how a credential appears in a shell command or
+        // an env file, which is most of how one appears in a coding transcript.
+        //
+        // The key must END in a secret-ish word so `PASSWORD_RESET_URL=/x` and
+        // `SECRET_NAME=haansi/dev/FOO` do not match: those name a secret rather
+        // than being one, and redacting them destroys useful context. A minimum
+        // length of 6 keeps `password=` and `secret=true` out.
+        id: "SECRET_ASSIGNMENT_UNQUOTED",
+        entityType: "SECRET",
+        pattern: /(?:^|[\s;&|"'`([{,])(?:[A-Za-z0-9_.-]*(?:password|passwd|secret|token|apikey|api_key))\s*[=:]\s*([^\s"'`;&|)\]}]{6,})/gim,
+        capture: 1,
+        replacement: "[REDACTED:SECRET]"
+      },
+      {
+        id: "BASIC_AUTH_URL",
+        entityType: "BASIC_AUTH",
+        pattern: /https?:\/\/([^:@\s/]+:[^@\s/]+)@/g,
+        capture: 1,
+        replacement: "[REDACTED:BASIC_AUTH]"
+      },
+      {
+        id: "CREDIT_CARD",
+        entityType: "CREDIT_CARD",
+        pattern: /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|6(?:011|5[0-9]{2})[0-9]{12}|(?:2131|1800|35\d{3})\d{11})\b/g,
+        replacement: "[REDACTED:CREDIT_CARD]"
+      },
+      {
+        id: "HAANSI_TOKEN",
+        entityType: "HAANSI_CLI_TOKEN",
+        pattern: /hsk_[a-f0-9]{32,}/g,
+        replacement: "[REDACTED:HAANSI_TOKEN]"
+      },
+      {
+        id: "BEARER_TOKEN",
+        entityType: "BEARER_TOKEN",
+        pattern: /Authorization:\s*Bearer\s+([A-Za-z0-9\-_.+/=]{20,})/gi,
+        capture: 1,
+        replacement: "[REDACTED:BEARER_TOKEN]"
+      },
+      {
+        id: "HEX_SECRET",
+        entityType: "HEX_SECRET",
+        pattern: /(?:token|secret|key|hash|salt)\s*[=:]\s*["']?([a-f0-9]{32,})["']?/gi,
+        capture: 1,
+        replacement: "[REDACTED:HEX_SECRET]"
+      }
+    ];
+    DETERMINISTIC_ENTITY_TYPES = new Set(
+      RULES.map((rule) => rule.entityType)
+    );
   }
 });
 
@@ -24812,264 +27281,6 @@ var init_src7 = __esm({
   }
 });
 
-// ../service-capture/common/agents/types.ts
-var AGENT_IDS;
-var init_types2 = __esm({
-  "../service-capture/common/agents/types.ts"() {
-    "use strict";
-    AGENT_IDS = ["claude-code", "codex"];
-  }
-});
-
-// ../service-capture/common/agents/claude-code.ts
-function projectsDir() {
-  return (0, import_path.join)((0, import_os.homedir)(), ".claude", "projects");
-}
-function extractMeta(filePath) {
-  const result = {
-    cwd: null,
-    timestamp: null,
-    gitBranch: null
-  };
-  try {
-    const lines = (0, import_fs.readFileSync)(filePath, "utf-8").split("\n").filter((l) => l.trim()).slice(0, 50);
-    for (const line of lines) {
-      try {
-        const entry2 = JSON.parse(line);
-        if (!result.cwd && typeof entry2.cwd === "string")
-          result.cwd = entry2.cwd;
-        if (!result.timestamp && typeof entry2.timestamp === "string")
-          result.timestamp = entry2.timestamp;
-        if (!result.gitBranch && typeof entry2.gitBranch === "string")
-          result.gitBranch = entry2.gitBranch;
-        if (result.cwd && result.timestamp && result.gitBranch) break;
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return result;
-}
-var import_fs, import_path, import_os, claudeCodeAgent;
-var init_claude_code = __esm({
-  "../service-capture/common/agents/claude-code.ts"() {
-    "use strict";
-    import_fs = require("fs");
-    import_path = require("path");
-    import_os = require("os");
-    claudeCodeAgent = {
-      id: "claude-code",
-      displayName: "Claude Code",
-      sessionsRoot() {
-        return projectsDir();
-      },
-      isInstalled() {
-        return (0, import_fs.existsSync)(projectsDir());
-      },
-      discoverSessions() {
-        const root = projectsDir();
-        if (!(0, import_fs.existsSync)(root)) return [];
-        const sessions = [];
-        const projectDirs = (0, import_fs.readdirSync)(root).map((name) => (0, import_path.join)(root, name)).filter((p) => {
-          try {
-            return (0, import_fs.statSync)(p).isDirectory();
-          } catch {
-            return false;
-          }
-        });
-        for (const dir of projectDirs) {
-          let files;
-          try {
-            files = (0, import_fs.readdirSync)(dir).filter((f) => f.endsWith(".jsonl"));
-          } catch {
-            continue;
-          }
-          for (const file2 of files) {
-            const filePath = (0, import_path.join)(dir, file2);
-            const sessionId = (0, import_path.basename)(file2, ".jsonl");
-            try {
-              const stat = (0, import_fs.statSync)(filePath);
-              const content = (0, import_fs.readFileSync)(filePath, "utf-8");
-              const lineCount = content.split("\n").filter((l) => l.trim()).length;
-              const meta3 = extractMeta(filePath);
-              sessions.push({
-                sessionId,
-                filePath,
-                lineCount,
-                sizeBytes: stat.size,
-                ...meta3
-              });
-            } catch {
-            }
-          }
-        }
-        return sessions;
-      }
-    };
-  }
-});
-
-// ../service-capture/common/agents/codex.ts
-function codexHome() {
-  return process.env.CODEX_HOME || (0, import_path2.join)((0, import_os2.homedir)(), ".codex");
-}
-function sessionsDir() {
-  return (0, import_path2.join)(codexHome(), "sessions");
-}
-function walkRollouts(dir, out) {
-  let entries;
-  try {
-    entries = (0, import_fs2.readdirSync)(dir);
-  } catch {
-    return;
-  }
-  for (const name of entries) {
-    const full = (0, import_path2.join)(dir, name);
-    let isDir = false;
-    try {
-      isDir = (0, import_fs2.statSync)(full).isDirectory();
-    } catch {
-      continue;
-    }
-    if (isDir) {
-      walkRollouts(full, out);
-    } else if (name.startsWith("rollout-") && name.endsWith(".jsonl")) {
-      out.push(full);
-    }
-  }
-}
-function readRolloutMeta(filePath, content) {
-  const fileName = (0, import_path2.basename)(filePath, ".jsonl");
-  const fromName = UUID_RE.exec(fileName)?.[1];
-  let cwd = null;
-  let timestamp = null;
-  let gitBranch = null;
-  let gitRemoteUrl = null;
-  let gitCommit = null;
-  let metaId = null;
-  const lines = content.split("\n").filter((l) => l.trim()).slice(0, 50);
-  for (const line of lines) {
-    try {
-      const entry2 = JSON.parse(line);
-      if (!timestamp && typeof entry2.timestamp === "string") {
-        timestamp = entry2.timestamp;
-      }
-      const p = entry2.payload ?? {};
-      if (entry2.type === "session_meta") {
-        if (typeof p.cwd === "string") cwd = p.cwd;
-        if (typeof p.id === "string") metaId = p.id;
-        const g = p.git ?? {};
-        const branch = g.branch ?? p.git_branch;
-        if (typeof branch === "string") gitBranch = branch;
-        const remote = g.repository_url ?? g.remote_url;
-        if (typeof remote === "string") gitRemoteUrl = remote;
-        const commit = g.commit_hash ?? g.commit;
-        if (typeof commit === "string") gitCommit = commit;
-      }
-      if (cwd && gitBranch && gitCommit && timestamp && metaId) break;
-    } catch {
-    }
-  }
-  return {
-    sessionId: fromName ?? metaId ?? fileName,
-    cwd,
-    timestamp,
-    gitBranch,
-    gitRemoteUrl,
-    gitCommit
-  };
-}
-var import_fs2, import_path2, import_os2, UUID_RE, codexAgent;
-var init_codex = __esm({
-  "../service-capture/common/agents/codex.ts"() {
-    "use strict";
-    import_fs2 = require("fs");
-    import_path2 = require("path");
-    import_os2 = require("os");
-    UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
-    codexAgent = {
-      id: "codex",
-      displayName: "OpenAI Codex",
-      sessionsRoot() {
-        return sessionsDir();
-      },
-      isInstalled() {
-        return (0, import_fs2.existsSync)(codexHome());
-      },
-      discoverSessions() {
-        const root = sessionsDir();
-        if (!(0, import_fs2.existsSync)(root)) return [];
-        const files = [];
-        walkRollouts(root, files);
-        const sessions = [];
-        for (const filePath of files) {
-          try {
-            const stat = (0, import_fs2.statSync)(filePath);
-            const content = (0, import_fs2.readFileSync)(filePath, "utf-8");
-            const lineCount = content.split("\n").filter((l) => l.trim()).length;
-            const meta3 = readRolloutMeta(filePath, content);
-            sessions.push({
-              sessionId: meta3.sessionId,
-              filePath,
-              lineCount,
-              sizeBytes: stat.size,
-              cwd: meta3.cwd,
-              timestamp: meta3.timestamp,
-              gitBranch: meta3.gitBranch,
-              gitRemoteUrl: meta3.gitRemoteUrl,
-              gitCommit: meta3.gitCommit
-            });
-          } catch {
-          }
-        }
-        return sessions;
-      }
-    };
-  }
-});
-
-// ../service-capture/common/agents/registry.ts
-function getAgents() {
-  return AGENTS;
-}
-function getAgent(id) {
-  const agent = AGENTS.find((a) => a.id === id);
-  if (!agent) throw new Error(`Unknown agent: ${id}`);
-  return agent;
-}
-function detectInstalled() {
-  return AGENTS.filter((a) => a.isInstalled());
-}
-var AGENTS;
-var init_registry = __esm({
-  "../service-capture/common/agents/registry.ts"() {
-    "use strict";
-    init_claude_code();
-    init_codex();
-    AGENTS = [claudeCodeAgent, codexAgent];
-  }
-});
-
-// ../service-capture/common/agents/index.ts
-var agents_exports = {};
-__export(agents_exports, {
-  AGENT_IDS: () => AGENT_IDS,
-  claudeCodeAgent: () => claudeCodeAgent,
-  codexAgent: () => codexAgent,
-  detectInstalled: () => detectInstalled,
-  getAgent: () => getAgent,
-  getAgents: () => getAgents
-});
-var init_agents = __esm({
-  "../service-capture/common/agents/index.ts"() {
-    "use strict";
-    init_types2();
-    init_claude_code();
-    init_codex();
-    init_registry();
-  }
-});
-
 // ../service-capture/agent-sessions/collector.ts
 var collector_exports = {};
 __export(collector_exports, {
@@ -25596,113 +27807,6 @@ var init_collector = __esm({
   }
 });
 
-// src/lib/agent-selection.ts
-var agent_selection_exports = {};
-__export(agent_selection_exports, {
-  parseAgentFlag: () => parseAgentFlag,
-  promptForAgents: () => promptForAgents,
-  readSavedAgents: () => readSavedAgents,
-  resolveAgentSelection: () => resolveAgentSelection,
-  saveAgents: () => saveAgents
-});
-function parseAgentFlag(value) {
-  if (!value) return null;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "both" || normalized === "all") return [...VALID];
-  const out = [];
-  for (const part of normalized.split(",").map((s) => s.trim())) {
-    if (part === "claude" || part === "claude-code") {
-      if (!out.includes("claude-code")) out.push("claude-code");
-    } else if (part === "codex") {
-      if (!out.includes("codex")) out.push("codex");
-    }
-  }
-  return out.length > 0 ? out : null;
-}
-function readSavedAgents() {
-  if (!(0, import_node_fs4.existsSync)(CONFIG_FILE)) return null;
-  try {
-    const cfg = JSON.parse((0, import_node_fs4.readFileSync)(CONFIG_FILE, "utf-8"));
-    if (Array.isArray(cfg.agents)) {
-      const agents = cfg.agents.filter(
-        (a) => VALID.includes(a)
-      );
-      return agents.length > 0 ? agents : null;
-    }
-  } catch {
-  }
-  return null;
-}
-function saveAgents(agents) {
-  let cfg = {};
-  if ((0, import_node_fs4.existsSync)(CONFIG_FILE)) {
-    try {
-      cfg = JSON.parse((0, import_node_fs4.readFileSync)(CONFIG_FILE, "utf-8"));
-    } catch {
-      cfg = {};
-    }
-  }
-  cfg.agents = agents;
-  (0, import_node_fs4.mkdirSync)(HAANSI_DIR, { recursive: true });
-  (0, import_node_fs4.writeFileSync)(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", {
-    encoding: "utf-8",
-    mode: 384
-  });
-}
-function resolveAgentSelection(flagValue) {
-  const fromFlag = parseAgentFlag(flagValue);
-  if (fromFlag) return { agents: fromFlag, source: "flag" };
-  const saved = readSavedAgents();
-  if (saved) return { agents: saved, source: "config" };
-  const detected = detectInstalled().map((a) => a.id);
-  if (detected.length > 0) return { agents: detected, source: "detected" };
-  return { agents: ["claude-code"], source: "default" };
-}
-async function promptForAgents() {
-  const installed = new Set(detectInstalled().map((a) => a.id));
-  const agents = getAgents();
-  console.log("\nWhich coding agents should Haansi connect?\n");
-  agents.forEach((a, i) => {
-    const mark = installed.has(a.id) ? "installed" : "not detected";
-    console.log(`  ${i + 1}) ${a.displayName} (${mark})`);
-  });
-  const rl = readline2.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const answer = await new Promise((resolve5) => {
-    rl.question(
-      "\nEnter numbers (comma-separated), or press Enter for all installed: ",
-      (a) => {
-        rl.close();
-        resolve5(a.trim());
-      }
-    );
-  });
-  if (!answer) {
-    const detected = agents.filter((a) => installed.has(a.id)).map((a) => a.id);
-    return detected.length > 0 ? detected : [...VALID];
-  }
-  const picked = [];
-  for (const token of answer.split(",").map((s) => s.trim())) {
-    const idx = parseInt(token, 10) - 1;
-    const agent = agents[idx];
-    if (agent && !picked.includes(agent.id)) picked.push(agent.id);
-  }
-  return picked.length > 0 ? picked : [...VALID];
-}
-var import_node_fs4, readline2, VALID;
-var init_agent_selection = __esm({
-  "src/lib/agent-selection.ts"() {
-    "use strict";
-    import_node_fs4 = require("node:fs");
-    readline2 = __toESM(require("node:readline"));
-    init_agents();
-    init_paths();
-    VALID = ["claude-code", "codex"];
-  }
-});
-
 // ../../node_modules/node-cron/src/task.js
 var require_task = __commonJS({
   "../../node_modules/node-cron/src/task.js"(exports2, module2) {
@@ -43651,11 +45755,11 @@ var require_util2 = __commonJS({
       return false;
     }
     exports2.schemaHasRules = schemaHasRules;
-    function schemaHasRulesButRef(schema, RULES) {
+    function schemaHasRulesButRef(schema, RULES2) {
       if (typeof schema == "boolean")
         return !schema;
       for (const key in schema)
-        if (key !== "$ref" && RULES.all[key])
+        if (key !== "$ref" && RULES2.all[key])
           return true;
       return false;
     }
@@ -45049,17 +47153,17 @@ var require_validate = __commonJS({
     }
     function schemaKeywords(it, types2, typeErrors, errsCount) {
       const { gen, schema, data, allErrors, opts, self } = it;
-      const { RULES } = self;
-      if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
-        gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
+      const { RULES: RULES2 } = self;
+      if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES2))) {
+        gen.block(() => keywordCode(it, "$ref", RULES2.all.$ref.definition));
         return;
       }
       if (!opts.jtd)
         checkStrictTypes(it, types2);
       gen.block(() => {
-        for (const group of RULES.rules)
+        for (const group of RULES2.rules)
           groupKeywords(group);
-        groupKeywords(RULES.post);
+        groupKeywords(RULES2.post);
       });
       function groupKeywords(group) {
         if (!(0, applicability_1.shouldUseGroup)(schema, group))
@@ -46761,10 +48865,10 @@ var require_core = __commonJS({
       }
       // Remove keyword
       removeKeyword(keyword) {
-        const { RULES } = this;
-        delete RULES.keywords[keyword];
-        delete RULES.all[keyword];
-        for (const group of RULES.rules) {
+        const { RULES: RULES2 } = this;
+        delete RULES2.keywords[keyword];
+        delete RULES2.all[keyword];
+        for (const group of RULES2.rules) {
           const i = group.rules.findIndex((rule) => rule.keyword === keyword);
           if (i >= 0)
             group.rules.splice(i, 1);
@@ -46932,9 +49036,9 @@ var require_core = __commonJS({
     }
     var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
     function checkKeyword(keyword, def) {
-      const { RULES } = this;
+      const { RULES: RULES2 } = this;
       (0, util_1.eachItem)(keyword, (kwd) => {
-        if (RULES.keywords[kwd])
+        if (RULES2.keywords[kwd])
           throw new Error(`Keyword ${kwd} is already defined`);
         if (!KEYWORD_NAME.test(kwd))
           throw new Error(`Keyword ${kwd} has invalid name`);
@@ -46950,13 +49054,13 @@ var require_core = __commonJS({
       const post = definition === null || definition === void 0 ? void 0 : definition.post;
       if (dataType && post)
         throw new Error('keyword with "post" flag cannot have "type"');
-      const { RULES } = this;
-      let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
+      const { RULES: RULES2 } = this;
+      let ruleGroup = post ? RULES2.post : RULES2.rules.find(({ type: t }) => t === dataType);
       if (!ruleGroup) {
         ruleGroup = { type: dataType, rules: [] };
-        RULES.rules.push(ruleGroup);
+        RULES2.rules.push(ruleGroup);
       }
-      RULES.keywords[keyword] = true;
+      RULES2.keywords[keyword] = true;
       if (!definition)
         return;
       const rule = {
@@ -46971,7 +49075,7 @@ var require_core = __commonJS({
         addBeforeRule.call(this, ruleGroup, rule, definition.before);
       else
         ruleGroup.rules.push(rule);
-      RULES.all[keyword] = rule;
+      RULES2.all[keyword] = rule;
       (_a3 = definition.implements) === null || _a3 === void 0 ? void 0 : _a3.forEach((kwd) => this.addKeyword(kwd));
     }
     function addBeforeRule(ruleGroup, rule, before) {
@@ -50306,11 +52410,11 @@ var require_util3 = __commonJS({
       return false;
     }
     exports2.schemaHasRules = schemaHasRules;
-    function schemaHasRulesButRef(schema, RULES) {
+    function schemaHasRulesButRef(schema, RULES2) {
       if (typeof schema == "boolean")
         return !schema;
       for (const key in schema)
-        if (key !== "$ref" && RULES.all[key])
+        if (key !== "$ref" && RULES2.all[key])
           return true;
       return false;
     }
@@ -51669,17 +53773,17 @@ var require_validate2 = __commonJS({
     }
     function schemaKeywords(it, types2, typeErrors, errsCount) {
       const { gen, schema, data, allErrors, opts, self } = it;
-      const { RULES } = self;
-      if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
-        gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
+      const { RULES: RULES2 } = self;
+      if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES2))) {
+        gen.block(() => keywordCode(it, "$ref", RULES2.all.$ref.definition));
         return;
       }
       if (!opts.jtd)
         checkStrictTypes(it, types2);
       gen.block(() => {
-        for (const group of RULES.rules)
+        for (const group of RULES2.rules)
           groupKeywords(group);
-        groupKeywords(RULES.post);
+        groupKeywords(RULES2.post);
       });
       function groupKeywords(group) {
         if (!(0, applicability_1.shouldUseGroup)(schema, group))
@@ -52659,10 +54763,10 @@ var require_core3 = __commonJS({
       }
       // Remove keyword
       removeKeyword(keyword) {
-        const { RULES } = this;
-        delete RULES.keywords[keyword];
-        delete RULES.all[keyword];
-        for (const group of RULES.rules) {
+        const { RULES: RULES2 } = this;
+        delete RULES2.keywords[keyword];
+        delete RULES2.all[keyword];
+        for (const group of RULES2.rules) {
           const i = group.rules.findIndex((rule) => rule.keyword === keyword);
           if (i >= 0)
             group.rules.splice(i, 1);
@@ -52830,9 +54934,9 @@ var require_core3 = __commonJS({
     }
     var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
     function checkKeyword(keyword, def) {
-      const { RULES } = this;
+      const { RULES: RULES2 } = this;
       (0, util_1.eachItem)(keyword, (kwd) => {
-        if (RULES.keywords[kwd])
+        if (RULES2.keywords[kwd])
           throw new Error(`Keyword ${kwd} is already defined`);
         if (!KEYWORD_NAME.test(kwd))
           throw new Error(`Keyword ${kwd} has invalid name`);
@@ -52848,13 +54952,13 @@ var require_core3 = __commonJS({
       const post = definition === null || definition === void 0 ? void 0 : definition.post;
       if (dataType && post)
         throw new Error('keyword with "post" flag cannot have "type"');
-      const { RULES } = this;
-      let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
+      const { RULES: RULES2 } = this;
+      let ruleGroup = post ? RULES2.post : RULES2.rules.find(({ type: t }) => t === dataType);
       if (!ruleGroup) {
         ruleGroup = { type: dataType, rules: [] };
-        RULES.rules.push(ruleGroup);
+        RULES2.rules.push(ruleGroup);
       }
-      RULES.keywords[keyword] = true;
+      RULES2.keywords[keyword] = true;
       if (!definition)
         return;
       const rule = {
@@ -52869,7 +54973,7 @@ var require_core3 = __commonJS({
         addBeforeRule.call(this, ruleGroup, rule, definition.before);
       else
         ruleGroup.rules.push(rule);
-      RULES.all[keyword] = rule;
+      RULES2.all[keyword] = rule;
       (_a3 = definition.implements) === null || _a3 === void 0 ? void 0 : _a3.forEach((kwd) => this.addKeyword(kwd));
     }
     function addBeforeRule(ruleGroup, rule, before) {
@@ -81109,222 +83213,6 @@ var init_mcp_server2 = __esm({
   }
 });
 
-// src/lib/codex-config.ts
-function tomlString(value) {
-  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-  return `"${escaped}"`;
-}
-function tomlStringArray(values) {
-  return `[${values.map(tomlString).join(", ")}]`;
-}
-function tomlInlineTable(entries) {
-  const parts = Object.entries(entries).map(
-    ([k, v]) => `${k} = ${tomlString(v)}`
-  );
-  return `{ ${parts.join(", ")} }`;
-}
-function upsertTomlTable(content, tablePath, entries) {
-  const bodyLines = Object.entries(entries).map(([k, v]) => `${k} = ${v}`);
-  const block = [`[${tablePath}]`, ...bodyLines].join("\n");
-  const lines = content.split("\n");
-  const headerRe = new RegExp(
-    `^\\s*\\[\\s*${tablePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\]\\s*$`
-  );
-  const startIdx = lines.findIndex((l) => headerRe.test(l));
-  if (startIdx === -1) {
-    const trimmed = content.replace(/\s*$/, "");
-    return trimmed.length > 0 ? `${trimmed}
-
-${block}
-` : `${block}
-`;
-  }
-  let endIdx = lines.length;
-  for (let i = startIdx + 1; i < lines.length; i++) {
-    if (/^\s*\[/.test(lines[i])) {
-      endIdx = i;
-      break;
-    }
-  }
-  const before = lines.slice(0, startIdx);
-  const after = lines.slice(endIdx);
-  const rebuilt = [...before, ...block.split("\n"), ...after].join("\n");
-  return rebuilt.replace(/\n{3,}/g, "\n\n");
-}
-var init_codex_config = __esm({
-  "src/lib/codex-config.ts"() {
-    "use strict";
-  }
-});
-
-// src/commands/setup-mcp.ts
-var setup_mcp_exports = {};
-__export(setup_mcp_exports, {
-  HTTP_SERVERS: () => HTTP_SERVERS,
-  parseTarget: () => parseTarget,
-  setupMcp: () => setupMcp
-});
-function parseTarget(arg) {
-  if (!arg || arg === "all") return "all";
-  if (arg === "solutions" || arg === "exchange" || arg === "digests" || arg === "onboarding" || arg === "skills")
-    return arg;
-  throw new Error(
-    `Unknown target: ${arg}. Use one of: solutions, exchange, digests, onboarding, skills, all (default).`
-  );
-}
-function httpServerUrl(path2) {
-  return `${apiUrl().replace(/\/+$/, "")}${path2}`;
-}
-function setupClaudeMcp(target) {
-  let config6 = {};
-  if ((0, import_node_fs5.existsSync)(CLAUDE_JSON)) {
-    try {
-      config6 = JSON.parse((0, import_node_fs5.readFileSync)(CLAUDE_JSON, "utf-8"));
-    } catch {
-      console.error(
-        `Warning: Could not parse ${CLAUDE_JSON} \u2014 will overwrite with new config.`
-      );
-    }
-  }
-  if (!config6.mcpServers) config6.mcpServers = {};
-  const installed = [];
-  const warnings = [];
-  if (target === "all" || target === "solutions") {
-    const haansiBin = resolveHaansiBin();
-    config6.mcpServers["haansi-solutions"] = {
-      command: haansiBin,
-      args: ["mcp-server"],
-      env: { HAANSI_AGENT_SOURCE: "claude-code" }
-    };
-    installed.push(`haansi-solutions (stdio \u2192 ${haansiBin} mcp-server)`);
-  }
-  for (const http of HTTP_SERVERS) {
-    if (target !== "all" && target !== http.target) continue;
-    const token = resolveToken();
-    if (!token) {
-      warnings.push(
-        `${http.name} not registered: no token found. Run \`haansi auth login\` first, or set HAANSI_TOKEN.`
-      );
-      continue;
-    }
-    const url2 = httpServerUrl(http.path);
-    config6.mcpServers[http.name] = {
-      type: "http",
-      url: url2,
-      headers: { Authorization: `Bearer ${token}` }
-    };
-    installed.push(`${http.name} (http \u2192 ${url2})`);
-  }
-  (0, import_node_fs5.writeFileSync)(CLAUDE_JSON, JSON.stringify(config6, null, 2) + "\n", "utf-8");
-  console.log(`
-Claude Code \u2014 configured in ${CLAUDE_JSON}`);
-  for (const entry2 of installed) console.log(`  \u2022 ${entry2}`);
-  for (const w of warnings) console.log(`  ! ${w}`);
-  return { installed, warnings };
-}
-function setupCodexMcp(target) {
-  let content = "";
-  if ((0, import_node_fs5.existsSync)(CODEX_CONFIG)) {
-    try {
-      content = (0, import_node_fs5.readFileSync)(CODEX_CONFIG, "utf-8");
-    } catch {
-      console.error(
-        `Warning: Could not read ${CODEX_CONFIG} \u2014 will create a new file.`
-      );
-    }
-  }
-  const installed = [];
-  const warnings = [];
-  if (target === "all" || target === "solutions") {
-    const haansiBin = resolveHaansiBin();
-    content = upsertTomlTable(content, "mcp_servers.haansi-solutions", {
-      command: tomlString(haansiBin),
-      args: tomlStringArray(["mcp-server"]),
-      env: tomlInlineTable({ HAANSI_AGENT_SOURCE: "codex" })
-    });
-    installed.push(`haansi-solutions (stdio \u2192 ${haansiBin} mcp-server)`);
-  }
-  for (const http of HTTP_SERVERS) {
-    if (target !== "all" && target !== http.target) continue;
-    const token = resolveToken();
-    if (!token) {
-      warnings.push(
-        `${http.name} not registered: no token found. Run \`haansi auth login\` first, or set HAANSI_TOKEN.`
-      );
-      continue;
-    }
-    const url2 = httpServerUrl(http.path);
-    content = upsertTomlTable(content, `mcp_servers.${http.name}`, {
-      url: tomlString(url2),
-      http_headers: tomlInlineTable({ Authorization: `Bearer ${token}` })
-    });
-    installed.push(`${http.name} (http \u2192 ${url2})`);
-  }
-  (0, import_node_fs5.mkdirSync)(CODEX_HOME, { recursive: true });
-  (0, import_node_fs5.writeFileSync)(CODEX_CONFIG, content, "utf-8");
-  console.log(`
-OpenAI Codex \u2014 configured in ${CODEX_CONFIG}`);
-  for (const entry2 of installed) console.log(`  \u2022 ${entry2}`);
-  for (const w of warnings) console.log(`  ! ${w}`);
-  return { installed, warnings };
-}
-async function setupMcp(targetArg, agentFlag) {
-  const target = parseTarget(targetArg);
-  const selection = resolveAgentSelection(agentFlag);
-  for (const agentId of selection.agents) {
-    WRITERS[agentId](target);
-  }
-  saveAgents(selection.agents);
-  const restart = selection.agents.map((a) => a === "codex" ? "Codex" : "Claude Code").join(" / ");
-  console.log(`
-Restart ${restart} to activate the changes.`);
-}
-var import_node_fs5, import_node_path4, import_node_os4, CLAUDE_JSON, CODEX_HOME, CODEX_CONFIG, HTTP_SERVERS, WRITERS;
-var init_setup_mcp = __esm({
-  "src/commands/setup-mcp.ts"() {
-    "use strict";
-    import_node_fs5 = require("node:fs");
-    import_node_path4 = require("node:path");
-    import_node_os4 = require("node:os");
-    init_paths();
-    init_agent_selection();
-    init_codex_config();
-    CLAUDE_JSON = (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".claude.json");
-    CODEX_HOME = process.env.CODEX_HOME || (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".codex");
-    CODEX_CONFIG = (0, import_node_path4.join)(CODEX_HOME, "config.toml");
-    HTTP_SERVERS = [
-      {
-        target: "exchange",
-        name: "haansi-exchange",
-        path: "/api/v1/memory/exchange/mcp"
-      },
-      {
-        target: "digests",
-        name: "haansi-digests",
-        path: "/api/v1/memory/digests/mcp"
-      },
-      // Published onboarding guides, so an agent can pick up a workstream from
-      // its handoff doc (docs/product/plans/2026-09-24-onboarding-guides.md §8.3).
-      {
-        target: "onboarding",
-        name: "haansi-onboarding",
-        path: "/api/v1/memory/onboarding/mcp"
-      },
-      // Published team skills, loaded progressively by coding agents
-      // (docs/product/plans/2026-10-10-memory-skills.md §7).
-      {
-        target: "skills",
-        name: "haansi-skills",
-        path: "/api/v1/memory/skills/mcp"
-      }
-    ];
-    WRITERS = {
-      "claude-code": setupClaudeMcp,
-      codex: setupCodexMcp
-    };
-  }
-});
-
 // src/commands/setup-daemon.ts
 var setup_daemon_exports = {};
 __export(setup_daemon_exports, {