total-recall-brain 3.13.0 → 3.13.2

package/src/core/project-brain.mjs

@@ -0,0 +1,349 @@
+/**
+ * Ensure a repo has a complete Total Recall *project brain*
+ * (not just skills folders).
+ *
+ * Layout:
+ *   <repo>/.agent/skills/total-recall/   ← brain root
+ *     memory-vault/{categories}/
+ *     memory-inbox/{pending,conflicts}/
+ *     memory-derived/
+ *     sessions/
+ *     scheduler/queue/
+ *     openwiki/
+ *     skills-registry/
+ *     config/brain.json
+ *   <repo>/.agent/skills/<user-skills>/  ← sibling agent skills
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import YAML from 'yaml';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '../..');
+
+export const VAULT_CATEGORIES = Object.freeze([
+  'invariants',
+  'patterns',
+  'anti-patterns',
+  'preferences',
+  'decisions',
+  'concepts',
+  'facts',
+  'corrections',
+  'lore',
+]);
+
+/**
+ * @param {string} repoRoot
+ * @returns {{ agentDir: string, brainDir: string, skillsDir: string }}
+ */
+export function resolveProjectBrainPaths(repoRoot) {
+  const root = path.resolve(repoRoot);
+  const agentDir = path.join(root, '.agent');
+  const skillsDir = path.join(agentDir, 'skills');
+  const brainDir = path.join(skillsDir, 'total-recall');
+  return { agentDir, brainDir, skillsDir, repoRoot: root };
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  }
+  return false;
+}
+
+function copyDirMerge(src, dest) {
+  if (!fs.existsSync(src)) return 0;
+  let n = 0;
+  ensureDir(dest);
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const from = path.join(src, entry.name);
+    const to = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      n += copyDirMerge(from, to);
+    } else if (!fs.existsSync(to)) {
+      fs.copyFileSync(from, to);
+      n++;
+    }
+  }
+  return n;
+}
+
+/**
+ * Seed openwiki pages (templates if packaged).
+ */
+export function ensureOpenWiki(brainDir) {
+  const wikiDir = path.join(brainDir, 'openwiki');
+  const created = ensureDir(wikiDir);
+  const templateRoot = path.join(ROOT, 'templates', 'openwiki');
+  let files = 0;
+  if (fs.existsSync(templateRoot)) {
+    files = copyDirMerge(templateRoot, wikiDir);
+  } else {
+    const pages = {
+      'README.md': `# OpenWiki\n\nProject knowledge docs for this Total Recall brain.\n`,
+      'memory.md': `# Memory\n\nUse \`npx total-recall remember\` / \`recall\` with --project.\n`,
+      'skills.md': `# Skills\n\nUser skills: \`.agent/skills/<name>/SKILL.md\`.\n`,
+      'ide.md': `# IDE\n\n\`npx total-recall connect <ide>\`\n`,
+      'secrets.md': `# Secrets\n\nNever put secrets in openwiki or vault markdown.\n`,
+    };
+    for (const [name, body] of Object.entries(pages)) {
+      const dest = path.join(wikiDir, name);
+      if (!fs.existsSync(dest)) {
+        fs.writeFileSync(dest, body);
+        files++;
+      }
+    }
+  }
+  return { wikiDir, created, files_added: files };
+}
+
+/**
+ * Ensure core total-recall skill package files exist (SKILL.md minimum).
+ */
+export function ensureCoreSkillPackage(brainDir) {
+  const skillMd = path.join(brainDir, 'SKILL.md');
+  if (fs.existsSync(skillMd)) return { seeded: false };
+  const scaffold = path.join(ROOT, 'scaffold', '.agent', 'skills', 'total-recall');
+  if (fs.existsSync(scaffold)) {
+    copyDirMerge(scaffold, brainDir);
+    return { seeded: true, from: 'scaffold' };
+  }
+  // Minimal SKILL.md so agents recognize the brain package
+  fs.writeFileSync(
+    skillMd,
+    `---
+name: total-recall
+description: "Use this skill to operate Total Recall — portable memory, instructions, openwiki, skill deploy, and secrets."
+---
+
+# Total Recall — Project Brain
+
+This directory is a **project brain**. Use CLI:
+
+\`\`\`bash
+npx total-recall remember fact "..." --project
+npx total-recall recall "..." --project
+npx total-recall compile
+npx total-recall dream
+\`\`\`
+`,
+  );
+  return { seeded: true, from: 'minimal' };
+}
+
+/**
+ * Write/update brain.json identity for a project brain.
+ */
+export function writeBrainIdentity(brainDir, { name, role = 'project', tags = [] } = {}) {
+  const configDir = path.join(brainDir, 'config');
+  ensureDir(configDir);
+  const brainJsonPath = path.join(configDir, 'brain.json');
+  let current = {};
+  if (fs.existsSync(brainJsonPath)) {
+    try {
+      current = JSON.parse(fs.readFileSync(brainJsonPath, 'utf8')) || {};
+    } catch {
+      current = {};
+    }
+  }
+  const next = {
+    ...current,
+    name: name || current.name || path.basename(path.resolve(brainDir, '../../..')),
+    role: 'project',
+    layer: 'project',
+    full_brain: true,
+    tags: [...new Set([...(current.tags || []), ...tags, 'project-brain'])],
+    updated_at: new Date().toISOString(),
+    created_at: current.created_at || new Date().toISOString(),
+  };
+  fs.writeFileSync(brainJsonPath, JSON.stringify(next, null, 2), { encoding: 'utf8', mode: 0o600 });
+  return next;
+}
+
+/**
+ * Ensure a full project brain under repoRoot/.agent/skills/total-recall/.
+ *
+ * @param {string} repoRoot
+ * @param {object} [opts]
+ * @param {string} [opts.name]
+ * @param {string[]} [opts.tags]
+ * @param {string} [opts.globalBrainDir] - for project-registry registration
+ * @param {boolean} [opts.register=true]
+ */
+export function ensureFullProjectBrain(repoRoot, opts = {}) {
+  const { agentDir, brainDir, skillsDir } = resolveProjectBrainPaths(repoRoot);
+  const name = opts.name || path.basename(path.resolve(repoRoot));
+  const tags = opts.tags || [];
+  const created = [];
+
+  if (ensureDir(agentDir)) created.push('agentDir');
+  if (ensureDir(skillsDir)) created.push('skillsDir');
+  if (ensureDir(brainDir)) created.push('brainDir');
+
+  const dataDirs = [
+    path.join(brainDir, 'memory-derived'),
+    path.join(brainDir, 'memory-inbox', 'pending'),
+    path.join(brainDir, 'memory-inbox', 'conflicts'),
+    path.join(brainDir, 'memory-inbox', 'capture'),
+    path.join(brainDir, 'sessions'),
+    path.join(brainDir, 'scheduler', 'queue'),
+    path.join(brainDir, 'skills-registry'),
+    path.join(brainDir, 'config'),
+    path.join(brainDir, 'logs'),
+    ...VAULT_CATEGORIES.map((c) => path.join(brainDir, 'memory-vault', c)),
+  ];
+  let dirsCreated = 0;
+  for (const d of dataDirs) {
+    if (ensureDir(d)) dirsCreated++;
+  }
+
+  const core = ensureCoreSkillPackage(brainDir);
+  const wiki = ensureOpenWiki(brainDir);
+  const identity = writeBrainIdentity(brainDir, { name, tags });
+
+  // Empty skills registry if missing
+  const regPath = path.join(brainDir, 'skills-registry', 'index.yaml');
+  if (!fs.existsSync(regPath)) {
+    fs.writeFileSync(
+      regPath,
+      YAML.stringify({
+        version: 1,
+        updated_at: new Date().toISOString(),
+        skills: {},
+        installs: [],
+      }),
+    );
+  }
+
+  let registry = null;
+  if (opts.register !== false) {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const gBrain =
+      opts.globalBrainDir || path.join(home, '.agent', 'skills', 'total-recall');
+    registry = registerProjectBrain(gBrain, {
+      name,
+      path: path.resolve(repoRoot),
+      brainDir,
+      tags: [...tags, 'full-brain', 'project-brain'],
+    });
+  }
+
+  return {
+    repoRoot: path.resolve(repoRoot),
+    agentDir,
+    brainDir,
+    skillsDir,
+    full_brain: true,
+    identity,
+    openwiki: wiki,
+    core,
+    dirs_created: dirsCreated,
+    created_top: created,
+    registry,
+  };
+}
+
+/**
+ * Register (or update) a project brain in global config/project-registry.json.
+ */
+export function registerProjectBrain(globalBrainDir, entry) {
+  const registryPath = path.join(globalBrainDir, 'config', 'project-registry.json');
+  ensureDir(path.dirname(registryPath));
+  let list = [];
+  if (fs.existsSync(registryPath)) {
+    try {
+      list = JSON.parse(fs.readFileSync(registryPath, 'utf8')) || [];
+    } catch {
+      list = [];
+    }
+  }
+  if (!Array.isArray(list)) list = [];
+
+  const abs = path.resolve(entry.path);
+  const idx = list.findIndex((p) => path.resolve(p.path || '') === abs);
+  const now = new Date().toISOString();
+  const row = {
+    name: entry.name,
+    path: abs,
+    brainDir: entry.brainDir,
+    full_brain: true,
+    layer: 'project',
+    tags: entry.tags || ['project-brain'],
+    registered_at: idx >= 0 ? list[idx].registered_at || now : now,
+    last_compiled: entry.last_compiled || list[idx]?.last_compiled || null,
+    updated_at: now,
+  };
+  if (idx >= 0) list[idx] = { ...list[idx], ...row };
+  else list.push(row);
+  fs.writeFileSync(registryPath, JSON.stringify(list, null, 2));
+  return row;
+}
+
+/**
+ * Ensure a path is a full project brain and register it.
+ * Requires an explicit repoRoot — no hardcoded product repos (open-source safe).
+ */
+export function ensureAndRegisterProjectBrain(opts = {}) {
+  const repoRoot = opts.repoRoot;
+  if (!repoRoot) {
+    return {
+      ok: false,
+      error:
+        'repoRoot required. Example: total-recall brain ensure /path/to/your/project',
+    };
+  }
+  if (!fs.existsSync(repoRoot)) {
+    return {
+      ok: false,
+      error: `Project path not found: ${repoRoot}`,
+    };
+  }
+
+  const name = opts.name || path.basename(path.resolve(repoRoot));
+  const result = ensureFullProjectBrain(repoRoot, {
+    name,
+    tags: [...(opts.tags || []), 'full-brain'],
+    globalBrainDir: opts.globalBrainDir,
+    register: true,
+  });
+
+  return { ok: true, ...result };
+}
+
+/**
+ * Quick health check: is this path a full project brain?
+ */
+export function inspectProjectBrain(repoRoot) {
+  const { brainDir, skillsDir } = resolveProjectBrainPaths(repoRoot);
+  const checks = {
+    brainDir: fs.existsSync(brainDir),
+    skillMd: fs.existsSync(path.join(brainDir, 'SKILL.md')),
+    memoryVault: fs.existsSync(path.join(brainDir, 'memory-vault')),
+    openwiki: fs.existsSync(path.join(brainDir, 'openwiki')),
+    sessions: fs.existsSync(path.join(brainDir, 'sessions')),
+    scheduler: fs.existsSync(path.join(brainDir, 'scheduler')),
+    skillsRegistry: fs.existsSync(path.join(brainDir, 'skills-registry')),
+    config: fs.existsSync(path.join(brainDir, 'config')),
+    siblingSkills: fs.existsSync(skillsDir),
+  };
+  const brainJsonPath = path.join(brainDir, 'config', 'brain.json');
+  let identity = null;
+  if (fs.existsSync(brainJsonPath)) {
+    try {
+      identity = JSON.parse(fs.readFileSync(brainJsonPath, 'utf8'));
+    } catch {}
+  }
+  const complete = Object.values(checks).every(Boolean);
+  return {
+    repoRoot: path.resolve(repoRoot),
+    brainDir,
+    checks,
+    complete,
+    full_brain: Boolean(identity?.full_brain) || complete,
+    identity,
+  };
+}

package/src/core/provider-catalog.mjs

@@ -0,0 +1,296 @@
+/**
+ * Static provider catalog — docs, schema hints, default subscription fields.
+ * Used by secrets UI/CLI; no secret values stored here.
+ */
+
+/** @typedef {{
+ *   id: string,
+ *   name: string,
+ *   docs_url: string,
+ *   pricing_url?: string,
+ *   console_url?: string,
+ *   key_patterns: string[],
+ *   schema: { auth: string, header?: string, env_keys: string[], notes?: string },
+ *   default_monthly_cap_usd?: number | null,
+ *   tiers?: { id: string, label: string, monthly_usd?: number | null }[],
+ * }} ProviderDef */
+
+/** @type {ProviderDef[]} */
+export const PROVIDER_CATALOG = [
+  {
+    id: 'openai',
+    name: 'OpenAI',
+    docs_url: 'https://platform.openai.com/docs/api-reference',
+    pricing_url: 'https://openai.com/api/pricing/',
+    console_url: 'https://platform.openai.com/api-keys',
+    key_patterns: ['OPENAI_API_KEY', 'AZURE_OPENAI_API_KEY'],
+    schema: {
+      auth: 'bearer',
+      header: 'Authorization: Bearer <key>',
+      env_keys: ['OPENAI_API_KEY'],
+      notes: 'Chat Completions + Responses APIs; org optional OPENAI_ORG_ID',
+    },
+    default_monthly_cap_usd: 50,
+    tiers: [
+      { id: 'free', label: 'Free / trial', monthly_usd: 0 },
+      { id: 'payg', label: 'Pay as you go', monthly_usd: null },
+      { id: 'team', label: 'Team', monthly_usd: null },
+    ],
+  },
+  {
+    id: 'anthropic',
+    name: 'Anthropic',
+    docs_url: 'https://docs.anthropic.com/en/api/getting-started',
+    pricing_url: 'https://www.anthropic.com/pricing',
+    console_url: 'https://console.anthropic.com/settings/keys',
+    key_patterns: ['ANTHROPIC_API_KEY'],
+    schema: {
+      auth: 'header',
+      header: 'x-api-key: <key>',
+      env_keys: ['ANTHROPIC_API_KEY'],
+      notes: 'Messages API; anthropic-version header required',
+    },
+    default_monthly_cap_usd: 50,
+    tiers: [
+      { id: 'free', label: 'Free', monthly_usd: 0 },
+      { id: 'build', label: 'Build / payg', monthly_usd: null },
+      { id: 'scale', label: 'Scale', monthly_usd: null },
+    ],
+  },
+  {
+    id: 'google',
+    name: 'Google AI / Gemini',
+    docs_url: 'https://ai.google.dev/gemini-api/docs',
+    pricing_url: 'https://ai.google.dev/pricing',
+    console_url: 'https://aistudio.google.com/apikey',
+    key_patterns: ['GOOGLE_API_KEY', 'GEMINI_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY'],
+    schema: {
+      auth: 'query_or_header',
+      header: 'x-goog-api-key: <key>',
+      env_keys: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+    },
+    default_monthly_cap_usd: 25,
+    tiers: [
+      { id: 'free', label: 'Free tier', monthly_usd: 0 },
+      { id: 'payg', label: 'Paid', monthly_usd: null },
+    ],
+  },
+  {
+    id: 'openrouter',
+    name: 'OpenRouter',
+    docs_url: 'https://openrouter.ai/docs',
+    pricing_url: 'https://openrouter.ai/models',
+    console_url: 'https://openrouter.ai/keys',
+    key_patterns: ['OPENROUTER_API_KEY'],
+    schema: {
+      auth: 'bearer',
+      header: 'Authorization: Bearer <key>',
+      env_keys: ['OPENROUTER_API_KEY'],
+      notes: 'OpenAI-compatible base URL https://openrouter.ai/api/v1',
+    },
+    default_monthly_cap_usd: 30,
+    tiers: [{ id: 'payg', label: 'Pay as you go', monthly_usd: null }],
+  },
+  {
+    id: 'xai',
+    name: 'xAI (Grok)',
+    docs_url: 'https://docs.x.ai/docs',
+    console_url: 'https://console.x.ai',
+    key_patterns: ['XAI_API_KEY', 'GROK_API_KEY'],
+    schema: {
+      auth: 'bearer',
+      header: 'Authorization: Bearer <key>',
+      env_keys: ['XAI_API_KEY'],
+    },
+    default_monthly_cap_usd: 30,
+    tiers: [{ id: 'payg', label: 'Pay as you go', monthly_usd: null }],
+  },
+  {
+    id: 'brave',
+    name: 'Brave Search',
+    docs_url: 'https://api-dashboard.search.brave.com/app/documentation',
+    console_url: 'https://api-dashboard.search.brave.com/',
+    key_patterns: ['BRAVE_SEARCH_API_KEY', 'BRAVE_API_KEY'],
+    schema: {
+      auth: 'header',
+      header: 'X-Subscription-Token: <key>',
+      env_keys: ['BRAVE_SEARCH_API_KEY'],
+    },
+    default_monthly_cap_usd: 5,
+    tiers: [
+      { id: 'free', label: 'Free', monthly_usd: 0 },
+      { id: 'base', label: 'Base', monthly_usd: 5 },
+      { id: 'pro', label: 'Pro', monthly_usd: null },
+    ],
+  },
+  {
+    id: 'elevenlabs',
+    name: 'ElevenLabs',
+    docs_url: 'https://elevenlabs.io/docs/api-reference',
+    pricing_url: 'https://elevenlabs.io/pricing',
+    console_url: 'https://elevenlabs.io/app/settings/api-keys',
+    key_patterns: ['ELEVENLABS_API_KEY', 'ELEVEN_LABS_API_KEY'],
+    schema: {
+      auth: 'header',
+      header: 'xi-api-key: <key>',
+      env_keys: ['ELEVENLABS_API_KEY'],
+    },
+    default_monthly_cap_usd: 22,
+    tiers: [
+      { id: 'free', label: 'Free', monthly_usd: 0 },
+      { id: 'starter', label: 'Starter', monthly_usd: 5 },
+      { id: 'creator', label: 'Creator', monthly_usd: 22 },
+      { id: 'pro', label: 'Pro', monthly_usd: 99 },
+    ],
+  },
+  {
+    id: 'github',
+    name: 'GitHub',
+    docs_url: 'https://docs.github.com/en/rest',
+    console_url: 'https://github.com/settings/tokens',
+    key_patterns: ['GITHUB_TOKEN', 'GH_TOKEN'],
+    schema: {
+      auth: 'bearer',
+      header: 'Authorization: Bearer <token>',
+      env_keys: ['GITHUB_TOKEN', 'GH_TOKEN'],
+    },
+    default_monthly_cap_usd: null,
+    tiers: [
+      { id: 'free', label: 'Free', monthly_usd: 0 },
+      { id: 'pro', label: 'Pro', monthly_usd: 4 },
+      { id: 'team', label: 'Team', monthly_usd: 4 },
+    ],
+  },
+  {
+    id: 'supabase',
+    name: 'Supabase',
+    docs_url: 'https://supabase.com/docs/reference/javascript/introduction',
+    console_url: 'https://supabase.com/dashboard',
+    key_patterns: ['SUPABASE_URL', 'SUPABASE_ANON_KEY', 'SUPABASE_SERVICE_ROLE_KEY'],
+    schema: {
+      auth: 'header',
+      header: 'apikey + Authorization Bearer',
+      env_keys: ['SUPABASE_URL', 'SUPABASE_ANON_KEY', 'SUPABASE_SERVICE_ROLE_KEY'],
+    },
+    default_monthly_cap_usd: 25,
+    tiers: [
+      { id: 'free', label: 'Free', monthly_usd: 0 },
+      { id: 'pro', label: 'Pro', monthly_usd: 25 },
+      { id: 'team', label: 'Team', monthly_usd: 599 },
+    ],
+  },
+  {
+    id: 'digitalocean',
+    name: 'DigitalOcean',
+    docs_url: 'https://docs.digitalocean.com/reference/api/',
+    console_url: 'https://cloud.digitalocean.com/account/api/tokens',
+    key_patterns: ['DIGITALOCEAN_API_TOKEN', 'DO_API_TOKEN', 'DIGITALOCEAN_ACCESS_TOKEN'],
+    schema: {
+      auth: 'bearer',
+      header: 'Authorization: Bearer <token>',
+      env_keys: ['DIGITALOCEAN_API_TOKEN'],
+    },
+    default_monthly_cap_usd: null,
+    tiers: [{ id: 'payg', label: 'Pay as you go', monthly_usd: null }],
+  },
+  {
+    id: 'huggingface',
+    name: 'Hugging Face',
+    docs_url: 'https://huggingface.co/docs/api-inference',
+    console_url: 'https://huggingface.co/settings/tokens',
+    key_patterns: ['HUGGINGFACE_API_KEY', 'HF_TOKEN'],
+    schema: {
+      auth: 'bearer',
+      header: 'Authorization: Bearer <token>',
+      env_keys: ['HF_TOKEN'],
+    },
+    default_monthly_cap_usd: 9,
+    tiers: [
+      { id: 'free', label: 'Free', monthly_usd: 0 },
+      { id: 'pro', label: 'Pro', monthly_usd: 9 },
+    ],
+  },
+  {
+    id: 'serper',
+    name: 'Serper',
+    docs_url: 'https://serper.dev/docs',
+    console_url: 'https://serper.dev',
+    key_patterns: ['SERPER_API_KEY'],
+    schema: {
+      auth: 'header',
+      header: 'X-API-KEY: <key>',
+      env_keys: ['SERPER_API_KEY'],
+    },
+    default_monthly_cap_usd: 50,
+    tiers: [{ id: 'payg', label: 'Credits', monthly_usd: null }],
+  },
+  {
+    id: 'telegram',
+    name: 'Telegram Bot',
+    docs_url: 'https://core.telegram.org/bots/api',
+    console_url: 'https://t.me/BotFather',
+    key_patterns: ['TELEGRAM_BOT_TOKEN', 'TELEGRAM_CHAT_ID'],
+    schema: {
+      auth: 'path',
+      env_keys: ['TELEGRAM_BOT_TOKEN', 'TELEGRAM_CHAT_ID'],
+      notes: 'Token from BotFather; chat_id for notifications',
+    },
+    default_monthly_cap_usd: 0,
+    tiers: [{ id: 'free', label: 'Free', monthly_usd: 0 }],
+  },
+  {
+    id: 'total-recall',
+    name: 'Total Recall',
+    docs_url: 'https://github.com/gregiteen/total-recall',
+    key_patterns: ['TOTAL_RECALL_TOKEN', 'TR_TOKEN', 'TR_SECRETS_PASSWORD'],
+    schema: {
+      auth: 'bearer',
+      header: 'Authorization: Bearer <pat>',
+      env_keys: ['TOTAL_RECALL_TOKEN'],
+      notes: 'Dashboard PATs via /api/keys; secrets.enc for provider keys',
+    },
+    default_monthly_cap_usd: 0,
+    tiers: [{ id: 'self-hosted', label: 'Self-hosted', monthly_usd: 0 }],
+  },
+];
+
+const byId = new Map(PROVIDER_CATALOG.map((p) => [p.id, p]));
+
+/**
+ * @param {string} providerId
+ */
+export function getProvider(providerId) {
+  if (!providerId) return null;
+  return byId.get(String(providerId).toLowerCase()) || null;
+}
+
+/**
+ * @param {string} keyName
+ */
+export function providerForKeyName(keyName) {
+  const k = String(keyName || '').toUpperCase();
+  for (const p of PROVIDER_CATALOG) {
+    if (p.key_patterns.some((pat) => pat.toUpperCase() === k || k.includes(pat.replace(/_API_KEY$/, '')))) {
+      return p;
+    }
+  }
+  // fuzzy
+  for (const p of PROVIDER_CATALOG) {
+    if (k.includes(p.id.toUpperCase().replace('-', '_'))) return p;
+  }
+  return null;
+}
+
+export function listProviders() {
+  return PROVIDER_CATALOG.map((p) => ({
+    id: p.id,
+    name: p.name,
+    docs_url: p.docs_url,
+    pricing_url: p.pricing_url || null,
+    console_url: p.console_url || null,
+    key_patterns: p.key_patterns,
+    schema: p.schema,
+    default_monthly_cap_usd: p.default_monthly_cap_usd ?? null,
+    tiers: p.tiers || [],
+  }));
+}

package/src/core/quick-capture.mjs

@@ -39,7 +39,7 @@ function classifyMessage(text) {
 
 function buildInboxNode({ text, author, channel, source, ts }) {
   const now = ts || new Date().toISOString();
-  const slug = `capture-${source}-${crypto.randomBytes(4).toString('hex')}`;
+  const slug = `capture-${source}-${crypto.createHash('md5').update(text).digest('hex').slice(0, 8)}`;
   const nodeType = classifyMessage(text);
 
   return {