@mycontxt/cli 0.1.7 → 0.1.8

package/dist/contxt.js

@@ -10,8 +10,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 import { Command } from "commander";
 
 // src/commands/init.ts
-import { mkdirSync } from "fs";
-import { basename } from "path";
+import { mkdirSync, existsSync as existsSync3, writeFileSync, readFileSync as readFileSync2, chmodSync } from "fs";
+import { basename, join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+import { spawn } from "child_process";
 import { SQLiteDatabase as SQLiteDatabase2 } from "@mycontxt/adapters/sqlite";
 
 // src/utils/project.ts
@@ -85,6 +87,9 @@ function error(message) {
 function info(message) {
   console.log(chalk.blue("\u2139"), message);
 }
+function warn(message) {
+  console.log(chalk.yellow("\u26A0"), message);
+}
 function formatEntry(entry) {
   const lines = [];
   lines.push(chalk.bold(entry.title));
@@ -119,11 +124,236 @@ function formatEntryList(entries) {
     return `  ${id}  ${title} ${time}`;
   }).join("\n");
 }
+function loading(message) {
+  console.log(chalk.cyan("~"), message);
+}
+function dryRun(message) {
+  console.log(chalk.dim("\u2192"), chalk.dim(message));
+}
+function conflict(message) {
+  console.log(chalk.yellow("!"), message);
+}
+function header(title) {
+  console.log(chalk.bold.cyan("\u203A"), chalk.bold(title));
+}
 function section(title) {
   return chalk.bold.underline(title);
 }
 
+// src/utils/usage-gate.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import chalk2 from "chalk";
+import { UsageGate } from "@mycontxt/core/engine/usage";
+import { resolveUserPlan } from "@mycontxt/core/engine/plan-resolver";
+import { SupabaseDatabase } from "@mycontxt/adapters/supabase";
+
+// src/config.ts
+var SUPABASE_URL = "";
+var SUPABASE_ANON_KEY = "";
+function getSupabaseConfig() {
+  if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+    throw new Error(
+      "Contxt is not configured for cloud sync.\nIf you installed via npm, please reinstall the latest version.\nIf building locally, set CONTXT_SUPABASE_URL and CONTXT_SUPABASE_ANON_KEY before running `pnpm build`."
+    );
+  }
+  return { url: SUPABASE_URL, anonKey: SUPABASE_ANON_KEY };
+}
+
+// src/utils/usage-gate.ts
+var AUTH_FILE = join2(homedir(), ".contxt", "auth.json");
+function getCurrentUserId() {
+  if (!existsSync2(AUTH_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(AUTH_FILE, "utf-8");
+    const auth2 = JSON.parse(content);
+    return auth2.userId;
+  } catch {
+    return null;
+  }
+}
+function getRemoteDb() {
+  if (!existsSync2(AUTH_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(AUTH_FILE, "utf-8");
+    const auth2 = JSON.parse(content);
+    const config = getSupabaseConfig();
+    return new SupabaseDatabase({
+      url: config.url,
+      anonKey: config.anonKey,
+      accessToken: auth2.accessToken
+    });
+  } catch {
+    return null;
+  }
+}
+async function getUsageCounts(localDb, userId, projectId) {
+  const projectCountQuery = "SELECT COUNT(*) as count FROM projects";
+  const projectRow = localDb.db.prepare(projectCountQuery).get();
+  const totalProjects = projectRow.count;
+  const totalEntriesQuery = "SELECT COUNT(*) as count FROM memory_entries WHERE is_archived = 0";
+  const totalEntriesRow = localDb.db.prepare(totalEntriesQuery).get();
+  const totalEntries = totalEntriesRow.count;
+  let entriesInProject = 0;
+  if (projectId) {
+    const projectEntriesQuery = "SELECT COUNT(*) as count FROM memory_entries WHERE project_id = ? AND is_archived = 0";
+    const projectEntriesRow = localDb.db.prepare(projectEntriesQuery).get(projectId);
+    entriesInProject = projectEntriesRow.count;
+  }
+  return {
+    totalProjects,
+    totalEntries,
+    entriesInProject,
+    totalSeats: 1
+    // Single user for now
+  };
+}
+async function createUsageGate(localDb, projectId) {
+  const userId = getCurrentUserId();
+  const remoteDb = getRemoteDb();
+  const planId = await resolveUserPlan(localDb, remoteDb, userId);
+  return new UsageGate(planId, () => getUsageCounts(localDb, userId, projectId));
+}
+function enforceGate(result) {
+  if (!result.allowed) {
+    console.error(chalk2.red(`
+\u2716 ${result.reason}`));
+    console.error(chalk2.dim(`  Current: ${result.current} / Limit: ${result.limit === null ? "\u221E" : result.limit}`));
+    console.error(chalk2.cyan(`
+  ${result.upgradeHint}
+`));
+    process.exit(1);
+  }
+}
+
 // src/commands/init.ts
+var CLAUDE_MD_TEMPLATE = `# Contxt \u2014 Active Context Capture
+
+This project uses [Contxt](https://mycontxt.co) (MCP) to automatically capture technical decisions and patterns from your conversations.
+
+## Your Role
+
+During every conversation in this project, actively capture knowledge using the Contxt MCP tools:
+
+- When the developer makes an architectural or technical decision \u2192 call \`contxt_auto_capture_decision\` or \`contxt_capture_discussion\`
+- When a reusable code pattern or convention is established \u2192 call \`contxt_auto_capture_pattern\`
+- At the end of each conversation \u2192 call \`contxt_update_session\` with a summary of what was accomplished
+
+Use a consistent \`conversationId\` (a UUID you generate at the start of the session) on every tool call so entries from the same conversation are linked.
+
+## When to Capture a Decision
+
+Capture a **decision** when the developer (or you together):
+- Chooses one technology, library, or approach over alternatives
+- Establishes a project structure, naming convention, or architectural boundary
+- Resolves a tradeoff (e.g. performance vs. simplicity, SQL vs. NoSQL)
+- Says "let's use X", "we'll go with Y", or "we decided to Z"
+
+Use \`contxt_capture_discussion\` when the decision came out of back-and-forth so you can capture the context and what was rejected.
+
+## When to Capture a Pattern
+
+Capture a **pattern** when:
+- A code shape is established that will be repeated (component structure, API format, hook convention, etc.)
+- A rule is set about how something should always be done in this project
+
+## What NOT to Capture
+
+- One-off debugging steps or experiments
+- Trivial implementation details (e.g. "added a console.log")
+- Things the developer explicitly says to ignore
+
+## After Capture
+
+All entries are saved as **drafts**. The developer reviews and confirms them with:
+\`\`\`
+contxt review
+\`\`\`
+`;
+var MCP_CONFIG = {
+  mcpServers: {
+    contxt: {
+      command: "contxt",
+      args: ["mcp"],
+      env: {}
+    }
+  }
+};
+var CONTXT_BLOCK_START = "# --- contxt hook start ---";
+var CONTXT_BLOCK_END = "# --- contxt hook end ---";
+var ALL_HOOKS = ["post-commit", "pre-push", "post-checkout", "prepare-commit-msg"];
+function writeMcpConfigs(cwd) {
+  const mcpJson = JSON.stringify(MCP_CONFIG, null, 2);
+  writeFileSync(join3(cwd, ".mcp.json"), mcpJson, "utf-8");
+  const cursorDir = join3(cwd, ".cursor");
+  mkdirSync(cursorDir, { recursive: true });
+  writeFileSync(join3(cursorDir, "mcp.json"), mcpJson, "utf-8");
+}
+function installGitHooks(cwd) {
+  const gitDir = join3(cwd, ".git");
+  if (!existsSync3(gitDir)) return false;
+  const gitHooksDir = join3(gitDir, "hooks");
+  mkdirSync(gitHooksDir, { recursive: true });
+  for (const hookName of ALL_HOOKS) {
+    const hookPath = join3(gitHooksDir, hookName);
+    const contxtBlock = `${CONTXT_BLOCK_START}
+contxt hook run ${hookName} "$@"
+${CONTXT_BLOCK_END}`;
+    if (existsSync3(hookPath)) {
+      const content = readFileSync2(hookPath, "utf-8");
+      if (!content.includes(CONTXT_BLOCK_START)) {
+        writeFileSync(hookPath, content.trimEnd() + "\n\n" + contxtBlock + "\n", "utf-8");
+      }
+    } else {
+      writeFileSync(hookPath, `#!/bin/sh
+
+${contxtBlock}
+`, "utf-8");
+    }
+    chmodSync(hookPath, "755");
+  }
+  return true;
+}
+function startWatchDaemon(cwd) {
+  const pidFile = join3(cwd, ".contxt", ".watch.pid");
+  if (existsSync3(pidFile)) return;
+  const child = spawn("contxt", ["watch", "--daemon"], {
+    detached: true,
+    stdio: "ignore",
+    cwd
+  });
+  child.unref();
+}
+function registerClaudeCodeHook() {
+  const claudeDir = join3(homedir2(), ".claude");
+  const settingsPath = join3(claudeDir, "settings.json");
+  const hookCommand2 = `bash -c 'PROMPT=$(cat | jq -r ".prompt // empty" 2>/dev/null | head -c 300); [ -n "$PROMPT" ] && contxt load --task "$PROMPT" 2>/dev/null || true'`;
+  let settings = {};
+  if (existsSync3(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
+  const alreadyRegistered = settings.hooks.UserPromptSubmit.some(
+    (h) => h.hooks?.some((hh) => typeof hh.command === "string" && hh.command.includes("contxt load"))
+  );
+  if (!alreadyRegistered) {
+    settings.hooks.UserPromptSubmit.push({
+      matcher: "",
+      hooks: [{ type: "command", command: hookCommand2 }]
+    });
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+}
 async function initCommand(options) {
   try {
     const cwd = process.cwd();
@@ -133,25 +363,34 @@ async function initCommand(options) {
     }
     const contxtDir = getContxtDir(cwd);
     mkdirSync(contxtDir, { recursive: true });
+    const claudeMdPath = join3(contxtDir, "CLAUDE.md");
+    writeFileSync(claudeMdPath, CLAUDE_MD_TEMPLATE, "utf-8");
     const dbPath = getDbPath(cwd);
     const db = new SQLiteDatabase2(dbPath);
     await db.initialize();
+    const gate = await createUsageGate(db);
+    const result = await gate.checkProjectCreate();
+    enforceGate(result);
     const projectName = options.name || basename(cwd);
     const project = await db.initProject({
       name: projectName,
       path: cwd,
-      stack: []
-      // TODO: Auto-detect stack
+      stack: [],
+      config: { autoSync: true }
     });
+    await db.close();
+    writeMcpConfigs(cwd);
+    const hooksInstalled = installGitHooks(cwd);
+    startWatchDaemon(cwd);
+    registerClaudeCodeHook();
     success(`Initialized Contxt project: ${project.name}`);
-    info(`Project ID: ${project.id}`);
-    info(`Database: ${dbPath}`);
     console.log();
-    console.log("Get started:");
-    console.log('  contxt decision add -t "..." -r "..."');
-    console.log('  contxt pattern add -t "..." -c "..."');
-    console.log("  contxt status");
-    await db.close();
+    info("\u2713 MCP server configured (.mcp.json + .cursor/mcp.json)");
+    if (hooksInstalled) info("\u2713 Git hooks installed (post-commit, pre-push, post-checkout)");
+    info("\u2713 Watch daemon started (auto-sync enabled)");
+    info("\u2713 Claude Code context hook registered");
+    console.log();
+    console.log("Contxt is running. You won't need to think about it again.");
   } catch (err) {
     error(`Failed to initialize project: ${err.message}`);
     process.exit(1);
@@ -162,6 +401,9 @@ async function initCommand(options) {
 async function add(options) {
   try {
     const { engine, projectId, db } = await loadProject();
+    const gate = await createUsageGate(db, projectId);
+    const result = await gate.checkEntryCreate();
+    enforceGate(result);
     const input = {
       title: options.title,
       rationale: options.rationale,
@@ -212,6 +454,9 @@ var decisionCommand = {
 async function add2(options) {
   try {
     const { engine, projectId, db } = await loadProject();
+    const gate = await createUsageGate(db, projectId);
+    const result = await gate.checkEntryCreate();
+    enforceGate(result);
     const input = {
       title: options.title,
       content: options.content,
@@ -314,7 +559,7 @@ var contextCommand = {
 };
 
 // src/commands/status.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 async function statusCommand() {
   try {
     const { engine, projectId, db } = await loadProject();
@@ -333,14 +578,14 @@ async function statusCommand() {
     console.log();
     console.log(section("Project Status"));
     console.log();
-    console.log(chalk2.bold("Name:"), project.name);
-    console.log(chalk2.bold("Path:"), project.path);
-    console.log(chalk2.bold("ID:"), project.id);
+    console.log(chalk3.bold("Name:"), project.name);
+    console.log(chalk3.bold("Path:"), project.path);
+    console.log(chalk3.bold("ID:"), project.id);
     console.log();
     console.log(section("Branches"));
     console.log();
     for (const branch2 of branches) {
-      const marker = branch2.name === activeBranch ? chalk2.green("\u25CF") : " ";
+      const marker = branch2.name === activeBranch ? chalk3.green("\u25CF") : " ";
       console.log(`  ${marker} ${branch2.name}`);
     }
     console.log();
@@ -356,21 +601,21 @@ async function statusCommand() {
       console.log(section("Current Context"));
       console.log();
       if (context2.metadata.feature) {
-        console.log(chalk2.bold("Feature:"), context2.metadata.feature);
+        console.log(chalk3.bold("Feature:"), context2.metadata.feature);
       }
       if (context2.metadata.blockers?.length > 0) {
-        console.log(chalk2.bold("Blockers:"));
+        console.log(chalk3.bold("Blockers:"));
         context2.metadata.blockers.forEach((b) => console.log(`  - ${b}`));
       }
       if (context2.metadata.nextSteps?.length > 0) {
-        console.log(chalk2.bold("Next Steps:"));
+        console.log(chalk3.bold("Next Steps:"));
         context2.metadata.nextSteps.forEach((s) => console.log(`  - ${s}`));
       }
       console.log();
     }
     if (unsynced.length > 0) {
-      console.log(chalk2.yellow(`\u26A0 ${unsynced.length} unsynced entries`));
-      console.log(chalk2.dim('  Run "contxt push" to sync'));
+      console.log(chalk3.yellow(`\u26A0 ${unsynced.length} unsynced entries`));
+      console.log(chalk3.dim('  Run "contxt push" to sync'));
       console.log();
     }
     await db.close();
@@ -381,14 +626,14 @@ async function statusCommand() {
 }
 
 // src/commands/doc.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 async function add3(options) {
   try {
     const { engine, projectId, db } = await loadProject();
     let content = options.content || "";
     if (options.file) {
       try {
-        content = readFileSync(options.file, "utf-8");
+        content = readFileSync3(options.file, "utf-8");
       } catch (err) {
         error(`Failed to read file: ${err.message}`);
         process.exit(1);
@@ -530,7 +775,7 @@ async function searchCommand(query, options) {
 }
 
 // src/commands/export.ts
-import { writeFileSync, readFileSync as readFileSync2 } from "fs";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync4 } from "fs";
 async function exportCommand(options) {
   try {
     const { engine, projectId, db } = await loadProject();
@@ -557,7 +802,7 @@ async function exportCommand(options) {
     };
     const json = JSON.stringify(exportData, null, 2);
     if (options.output) {
-      writeFileSync(options.output, json, "utf-8");
+      writeFileSync2(options.output, json, "utf-8");
       success(`Exported ${entries.length} entries to ${options.output}`);
     } else {
       console.log(json);
@@ -573,7 +818,7 @@ async function importCommand(options) {
     const { engine, projectId, db } = await loadProject();
     let data;
     try {
-      const json = readFileSync2(options.file, "utf-8");
+      const json = readFileSync4(options.file, "utf-8");
       data = JSON.parse(json);
     } catch (err) {
       error(`Failed to read import file: ${err.message}`);
@@ -610,37 +855,23 @@ async function importCommand(options) {
 
 // src/commands/auth.ts
 import { SupabaseAuth } from "@mycontxt/adapters/supabase-auth";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3 } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
-
-// src/config.ts
-var SUPABASE_URL = "https://nreejrbrgbpcteliqqxm.supabase.co";
-var SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im5yZWVqcmJyZ2JwY3RlbGlxcXhtIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzEyODU3MDcsImV4cCI6MjA4Njg2MTcwN30.1oMu3WWwPQj1PU9jkAeWt7dbzaS4LN99pMkc299RWhY";
-function getSupabaseConfig() {
-  if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
-    throw new Error(
-      "Contxt is not configured for cloud sync.\nIf you installed via npm, please reinstall the latest version.\nIf building locally, set CONTXT_SUPABASE_URL and CONTXT_SUPABASE_ANON_KEY before running `pnpm build`."
-    );
-  }
-  return { url: SUPABASE_URL, anonKey: SUPABASE_ANON_KEY };
-}
-
-// src/commands/auth.ts
-var CONFIG_DIR = join2(homedir(), ".contxt");
-var AUTH_FILE = join2(CONFIG_DIR, "auth.json");
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+var CONFIG_DIR = join4(homedir3(), ".contxt");
+var AUTH_FILE2 = join4(CONFIG_DIR, "auth.json");
 function saveAuthData(data) {
-  if (!existsSync3(CONFIG_DIR)) {
+  if (!existsSync4(CONFIG_DIR)) {
     mkdirSync2(CONFIG_DIR, { recursive: true });
   }
-  writeFileSync2(AUTH_FILE, JSON.stringify(data, null, 2), "utf-8");
+  writeFileSync3(AUTH_FILE2, JSON.stringify(data, null, 2), "utf-8");
 }
 function loadAuthData() {
-  if (!existsSync3(AUTH_FILE)) {
+  if (!existsSync4(AUTH_FILE2)) {
     return null;
   }
   try {
-    const content = readFileSync3(AUTH_FILE, "utf-8");
+    const content = readFileSync5(AUTH_FILE2, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -651,10 +882,12 @@ var authCommand = {
     try {
       const config = getSupabaseConfig();
       const auth2 = new SupabaseAuth(config);
-      console.log("\u{1F510} Contxt Authentication\n");
+      header("Contxt Authentication");
+      console.log("");
       if (options.email) {
         await auth2.loginWithMagicLink(options.email);
-        console.log("\n\u2705 Magic link sent! Check your email and click the link.");
+        console.log("");
+        success("Magic link sent! Check your email and click the link.");
         console.log("   Then run `contxt auth status` to verify.");
       } else {
         console.log("Opening browser for GitHub authentication...\n");
@@ -665,18 +898,16 @@ var authCommand = {
           email: result.user.email,
           githubUsername: result.user.githubUsername
         });
-        console.log("\n\u2705 Successfully authenticated!");
+        console.log("");
+        success("Successfully authenticated!");
         console.log(`   Email: ${result.user.email}`);
         if (result.user.githubUsername) {
           console.log(`   GitHub: @${result.user.githubUsername}`);
         }
         console.log("\nYou can now use `contxt push` and `contxt pull` to sync your memory.");
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Authentication failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Authentication failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -685,16 +916,13 @@ var authCommand = {
       const config = getSupabaseConfig();
       const auth2 = new SupabaseAuth(config);
       await auth2.logout();
-      if (existsSync3(AUTH_FILE)) {
+      if (existsSync4(AUTH_FILE2)) {
         const fs = await import("fs/promises");
-        await fs.unlink(AUTH_FILE);
+        await fs.unlink(AUTH_FILE2);
       }
-      console.log("\u2705 Logged out successfully");
-    } catch (error2) {
-      console.error(
-        "\u274C Logout failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+      success("Logged out successfully");
+    } catch (err) {
+      error(`Logout failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -702,11 +930,11 @@ var authCommand = {
     try {
       const authData = loadAuthData();
       if (!authData) {
-        console.log("\u274C Not authenticated");
+        error("Not authenticated");
         console.log("\nRun `contxt auth login` to authenticate.");
         process.exit(1);
       }
-      console.log("\u2705 Authenticated");
+      success("Authenticated");
       console.log(`   Email: ${authData.email}`);
       if (authData.githubUsername) {
         console.log(`   GitHub: @${authData.githubUsername}`);
@@ -716,15 +944,14 @@ var authCommand = {
       const auth2 = new SupabaseAuth(config);
       try {
         await auth2.refreshSession();
-        console.log("\n\u2705 Session is valid");
+        console.log("");
+        success("Session is valid");
       } catch {
-        console.log("\n\u26A0\uFE0F  Session expired. Run `contxt auth login` to re-authenticate.");
+        console.log("");
+        warn("Session expired. Run `contxt auth login` to re-authenticate.");
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Status check failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Status check failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   }
@@ -736,7 +963,7 @@ function getAccessToken() {
 
 // src/commands/sync.ts
 import { SQLiteDatabase as SQLiteDatabase3 } from "@mycontxt/adapters/sqlite";
-import { SupabaseDatabase } from "@mycontxt/adapters/supabase";
+import { SupabaseDatabase as SupabaseDatabase2 } from "@mycontxt/adapters/supabase";
 import { SyncEngine } from "@mycontxt/core";
 var syncCommand = {
   /**
@@ -746,7 +973,7 @@ var syncCommand = {
     try {
       const accessToken = getAccessToken();
       if (!accessToken) {
-        console.error("\u274C Not authenticated. Run `contxt auth login` first.");
+        error("Not authenticated. Run `contxt auth login` first.");
         process.exit(1);
       }
       const dbPath = getDbPath();
@@ -756,45 +983,41 @@ var syncCommand = {
         const cwd = process.cwd();
         const project = await localDb.getProjectByPath(cwd);
         if (!project) {
-          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          error("No Contxt project found. Run `contxt init` first.");
           process.exit(1);
         }
         const supabaseConfig = getSupabaseConfig();
-        const remoteDb = new SupabaseDatabase({
+        const remoteDb = new SupabaseDatabase2({
           ...supabaseConfig,
           accessToken
         });
         await remoteDb.initialize();
         const syncEngine = new SyncEngine(localDb, remoteDb);
-        console.log("\u{1F504} Pushing local changes to cloud...\n");
+        loading("Pushing local changes to cloud...");
+        console.log("");
         const result = await syncEngine.push(project.id, {
           force: options.force,
           dryRun: options.dryRun
         });
         if (result.errors.length > 0) {
-          console.error("\u274C Push failed:");
+          error("Push failed:");
           result.errors.forEach((err) => console.error(`   ${err}`));
           process.exit(1);
         }
         if (options.dryRun) {
-          console.log(`\u{1F4CB} Dry run - would push ${result.pushed} entries`);
+          dryRun(`Dry run \u2014 would push ${result.pushed} entries`);
         } else {
-          console.log(`\u2705 Successfully pushed ${result.pushed} entries`);
+          success(`Pushed ${result.pushed} entries`);
         }
         if (result.conflicts > 0) {
-          console.log(
-            `\u26A0\uFE0F  ${result.conflicts} conflict(s) detected. Use --force to override.`
-          );
+          conflict(`${result.conflicts} conflict(s) detected. Use --force to override.`);
         }
         await remoteDb.close();
       } finally {
         await localDb.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Push failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Push failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -805,7 +1028,7 @@ var syncCommand = {
     try {
       const accessToken = getAccessToken();
       if (!accessToken) {
-        console.error("\u274C Not authenticated. Run `contxt auth login` first.");
+        error("Not authenticated. Run `contxt auth login` first.");
         process.exit(1);
       }
       const dbPath = getDbPath();
@@ -815,45 +1038,41 @@ var syncCommand = {
         const cwd = process.cwd();
         const project = await localDb.getProjectByPath(cwd);
         if (!project) {
-          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          error("No Contxt project found. Run `contxt init` first.");
           process.exit(1);
         }
         const supabaseConfig = getSupabaseConfig();
-        const remoteDb = new SupabaseDatabase({
+        const remoteDb = new SupabaseDatabase2({
           ...supabaseConfig,
           accessToken
         });
         await remoteDb.initialize();
         const syncEngine = new SyncEngine(localDb, remoteDb);
-        console.log("\u{1F504} Pulling remote changes to local...\n");
+        loading("Pulling remote changes to local...");
+        console.log("");
         const result = await syncEngine.pull(project.id, {
           force: options.force,
           dryRun: options.dryRun
         });
         if (result.errors.length > 0) {
-          console.error("\u274C Pull failed:");
+          error("Pull failed:");
           result.errors.forEach((err) => console.error(`   ${err}`));
           process.exit(1);
         }
         if (options.dryRun) {
-          console.log(`\u{1F4CB} Dry run - would pull ${result.pulled} entries`);
+          dryRun(`Dry run \u2014 would pull ${result.pulled} entries`);
         } else {
-          console.log(`\u2705 Successfully pulled ${result.pulled} entries`);
+          success(`Pulled ${result.pulled} entries`);
         }
         if (result.conflicts > 0) {
-          console.log(
-            `\u26A0\uFE0F  ${result.conflicts} conflict(s) detected. Use --force to override.`
-          );
+          conflict(`${result.conflicts} conflict(s) detected. Use --force to override.`);
         }
         await remoteDb.close();
       } finally {
         await localDb.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Pull failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Pull failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -864,7 +1083,7 @@ var syncCommand = {
     try {
       const accessToken = getAccessToken();
       if (!accessToken) {
-        console.error("\u274C Not authenticated. Run `contxt auth login` first.");
+        error("Not authenticated. Run `contxt auth login` first.");
         process.exit(1);
       }
       const dbPath = getDbPath();
@@ -874,49 +1093,43 @@ var syncCommand = {
         const cwd = process.cwd();
         const project = await localDb.getProjectByPath(cwd);
         if (!project) {
-          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          error("No Contxt project found. Run `contxt init` first.");
           process.exit(1);
         }
         const supabaseConfig = getSupabaseConfig();
-        const remoteDb = new SupabaseDatabase({
+        const remoteDb = new SupabaseDatabase2({
           ...supabaseConfig,
           accessToken
         });
         await remoteDb.initialize();
         const syncEngine = new SyncEngine(localDb, remoteDb);
-        console.log("\u{1F504} Syncing with cloud (pull + push)...\n");
+        loading("Syncing with cloud (pull + push)...");
+        console.log("");
         const result = await syncEngine.sync(project.id, {
           force: options.force,
           dryRun: options.dryRun
         });
         if (result.errors.length > 0) {
-          console.error("\u274C Sync failed:");
+          error("Sync failed:");
           result.errors.forEach((err) => console.error(`   ${err}`));
           process.exit(1);
         }
         if (options.dryRun) {
-          console.log(
-            `\u{1F4CB} Dry run - would pull ${result.pulled} and push ${result.pushed} entries`
-          );
+          dryRun(`Dry run \u2014 would pull ${result.pulled} and push ${result.pushed} entries`);
         } else {
-          console.log(`\u2705 Successfully synced`);
+          success("Synced successfully");
           console.log(`   Pulled: ${result.pulled} entries`);
           console.log(`   Pushed: ${result.pushed} entries`);
         }
         if (result.conflicts > 0) {
-          console.log(
-            `\u26A0\uFE0F  ${result.conflicts} conflict(s) detected. Use --force to override.`
-          );
+          conflict(`${result.conflicts} conflict(s) detected. Use --force to override.`);
         }
         await remoteDb.close();
       } finally {
         await localDb.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Sync failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Sync failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   }
@@ -937,20 +1150,20 @@ var branchCommand = {
         const cwd = process.cwd();
         const project = await db.getProjectByPath(cwd);
         if (!project) {
-          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          error("No Contxt project found. Run `contxt init` first.");
           process.exit(1);
         }
+        const gate = await createUsageGate(db, project.id);
+        const result = gate.checkFeature("branchingEnabled");
+        enforceGate(result);
         const fromBranch = options.from || await db.getActiveBranch(project.id);
         await db.createBranch(project.id, name, fromBranch);
-        console.log(`\u2705 Created branch '${name}' from '${fromBranch}'`);
+        success(`Created branch '${name}' from '${fromBranch}'`);
       } finally {
         await db.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Branch create failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Branch create failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -966,7 +1179,7 @@ var branchCommand = {
         const cwd = process.cwd();
         const project = await db.getProjectByPath(cwd);
         if (!project) {
-          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          error("No Contxt project found. Run `contxt init` first.");
           process.exit(1);
         }
         const branches = await db.listBranches(project.id);
@@ -980,11 +1193,8 @@ var branchCommand = {
       } finally {
         await db.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Branch list failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Branch list failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -1000,19 +1210,19 @@ var branchCommand = {
         const cwd = process.cwd();
         const project = await db.getProjectByPath(cwd);
         if (!project) {
-          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          error("No Contxt project found. Run `contxt init` first.");
           process.exit(1);
         }
+        const gate = await createUsageGate(db, project.id);
+        const result = gate.checkFeature("branchingEnabled");
+        enforceGate(result);
         await db.switchBranch(project.id, name);
-        console.log(`\u2705 Switched to branch '${name}'`);
+        success(`Switched to branch '${name}'`);
       } finally {
         await db.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Branch switch failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Branch switch failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -1028,28 +1238,25 @@ var branchCommand = {
         const cwd = process.cwd();
         const project = await db.getProjectByPath(cwd);
         if (!project) {
-          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          error("No Contxt project found. Run `contxt init` first.");
           process.exit(1);
         }
         const activeBranch = await db.getActiveBranch(project.id);
         if (name === activeBranch) {
-          console.error("\u274C Cannot delete active branch. Switch to another branch first.");
+          error("Cannot delete active branch. Switch to another branch first.");
           process.exit(1);
         }
         if (name === "main") {
-          console.error("\u274C Cannot delete main branch.");
+          error("Cannot delete main branch.");
           process.exit(1);
         }
         await db.deleteBranch(project.id, name);
-        console.log(`\u2705 Deleted branch '${name}'`);
+        success(`Deleted branch '${name}'`);
       } finally {
         await db.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Branch delete failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Branch delete failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -1065,12 +1272,12 @@ var branchCommand = {
         const cwd = process.cwd();
         const project = await db.getProjectByPath(cwd);
         if (!project) {
-          console.error("\u274C No Contxt project found. Run `contxt init` first.");
+          error("No Contxt project found. Run `contxt init` first.");
           process.exit(1);
         }
         const targetBranch = await db.getActiveBranch(project.id);
         if (sourceBranch === targetBranch) {
-          console.error("\u274C Cannot merge a branch into itself.");
+          error("Cannot merge a branch into itself.");
           process.exit(1);
         }
         const sourceEntries = await db.listEntries({
@@ -1106,17 +1313,12 @@ var branchCommand = {
             merged++;
           }
         }
-        console.log(
-          `\u2705 Merged ${merged} entries from '${sourceBranch}' into '${targetBranch}'`
-        );
+        success(`Merged ${merged} entries from '${sourceBranch}' into '${targetBranch}'`);
       } finally {
         await db.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Branch merge failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Branch merge failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   }
@@ -1136,17 +1338,17 @@ var historyCommand = {
       try {
         const entry = await db.getEntry(entryId);
         if (!entry) {
-          console.error("\u274C Entry not found.");
+          error("Entry not found.");
           process.exit(1);
         }
         const versions = await db.getVersionHistory(entryId);
-        console.log(`\u{1F4DC} Version History: ${entry.title}
-`);
+        console.log(section(`Version History: ${entry.title}`));
+        console.log("");
         console.log(`Current (v${entry.version}):`);
         console.log(`  Updated: ${entry.updatedAt.toLocaleString()}`);
         console.log(`  Title: ${entry.title}`);
-        console.log(`  Content: ${entry.content.substring(0, 100)}${entry.content.length > 100 ? "..." : ""}
-`);
+        console.log(`  Content: ${entry.content.substring(0, 100)}${entry.content.length > 100 ? "..." : ""}`);
+        console.log("");
         if (versions.length > 0) {
           console.log("Previous versions:");
           for (const version of versions) {
@@ -1164,11 +1366,8 @@ v${version.version}:`);
       } finally {
         await db.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C History failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`History failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   },
@@ -1182,16 +1381,13 @@ v${version.version}:`);
       await db.initialize();
       try {
         const restored = await db.restoreVersion(entryId, options.version);
-        console.log(`\u2705 Restored '${restored.title}' to version ${options.version}`);
+        success(`Restored '${restored.title}' to version ${options.version}`);
         console.log(`   Current version is now: v${restored.version}`);
       } finally {
         await db.close();
       }
-    } catch (error2) {
-      console.error(
-        "\u274C Restore failed:",
-        error2 instanceof Error ? error2.message : error2
-      );
+    } catch (err) {
+      error(`Restore failed: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
     }
   }
@@ -1199,7 +1395,36 @@ v${version.version}:`);
 
 // src/commands/load.ts
 import { SQLiteDatabase as SQLiteDatabase6 } from "@mycontxt/adapters/sqlite";
+import { SupabaseDatabase as SupabaseDatabase3 } from "@mycontxt/adapters/supabase";
 import { buildContextPayload, buildContextSummary } from "@mycontxt/core";
+import chalk4 from "chalk";
+var MODEL_COSTS_PER_1K = {
+  "claude-sonnet": 3e-3,
+  "claude-haiku": 25e-5,
+  "claude-opus": 0.015,
+  "gpt-4o": 25e-4,
+  "gpt-4": 0.03,
+  "gpt-3.5": 5e-4
+};
+var DEFAULT_MODEL = "claude-sonnet";
+function formatCost(tokens, model) {
+  const costPerK = MODEL_COSTS_PER_1K[model] ?? MODEL_COSTS_PER_1K[DEFAULT_MODEL];
+  const cost = tokens / 1e3 * costPerK;
+  return `$${cost.toFixed(4)}`;
+}
+async function generateQueryEmbedding(text, apiKey) {
+  try {
+    const res = await fetch("https://api.openai.com/v1/embeddings", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "text-embedding-3-small", input: text })
+    });
+    const data = await res.json();
+    return data.data?.[0]?.embedding ?? null;
+  } catch {
+    return null;
+  }
+}
 async function loadCommand(options) {
   try {
     const dbPath = getDbPath();
@@ -1209,7 +1434,7 @@ async function loadCommand(options) {
       const cwd = process.cwd();
       const project = await db.getProjectByPath(cwd);
       if (!project) {
-        console.error("\u274C No Contxt project found. Run `contxt init` first.");
+        error("No Contxt project found. Run `contxt init` first.");
         process.exit(1);
       }
       const branch2 = await db.getActiveBranch(project.id);
@@ -1224,11 +1449,11 @@ async function loadCommand(options) {
       }
       if (options.summary) {
         const summary = buildContextSummary(entries);
-        console.log(`\u{1F4CA} Context Summary
-`);
+        console.log(section("Context Summary"));
+        console.log("");
         console.log(`Total entries: ${summary.totalEntries}`);
-        console.log(`Branch: ${branch2}
-`);
+        console.log(`Branch: ${branch2}`);
+        console.log("");
         console.log("By type:");
         for (const [type, count] of Object.entries(summary.byType)) {
           console.log(`  ${type}: ${count}`);
@@ -1256,7 +1481,30 @@ Date range: ${summary.oldestEntry.toLocaleDateString()} - ${summary.newestEntry.
       } else if (options.all) {
         mode = "all";
       }
-      const result = buildContextPayload(entries, {
+      const totalEntryCount = entries.length;
+      let resolvedEntries = entries;
+      if (mode === "task" && options.task) {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (apiKey) {
+          try {
+            const config = getSupabaseConfig();
+            const remoteDb = new SupabaseDatabase3(config);
+            const embedding = await generateQueryEmbedding(options.task, apiKey);
+            if (embedding) {
+              const semanticResults = await remoteDb.semanticSearch(project.id, embedding, {
+                branch: branch2,
+                limit: 20,
+                minSimilarity: 0.65
+              }).catch(() => []);
+              if (semanticResults.length > 0) {
+                resolvedEntries = semanticResults;
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      const result = buildContextPayload(resolvedEntries, {
         projectId: project.id,
         type: mode,
         taskDescription: options.task,
@@ -1265,26 +1513,36 @@ Date range: ${summary.oldestEntry.toLocaleDateString()} - ${summary.newestEntry.
         includeTypes: options.type ? [options.type] : void 0
       });
       console.log(result.context);
-      console.error(
-        `
-\u{1F4E6} Context: ${result.entriesIncluded} entries, ${result.tokensUsed}/${result.budget} tokens`
-      );
+      const model = process.env.CONTXT_MODEL ?? DEFAULT_MODEL;
+      const totalFiltered = totalEntryCount - result.entriesIncluded;
+      if (totalFiltered > 0 && result.tokensSaved > 0) {
+        const filteredCost = formatCost(result.tokensUsed, model);
+        const fullCost = formatCost(result.tokensUsed + result.tokensSaved, model);
+        console.error(
+          chalk4.dim(
+            `
+\u2192 ${result.entriesIncluded} entries loaded \xB7 ${result.tokensUsed} tokens \xB7 saved ${result.tokensSaved.toLocaleString()} tokens (${totalFiltered} filtered) \xB7 ~${filteredCost} vs ${fullCost} full load`
+          )
+        );
+      } else {
+        console.error(
+          chalk4.dim(`
+\u2192 ${result.entriesIncluded} entries loaded \xB7 ${result.tokensUsed}/${result.budget} tokens`)
+        );
+      }
     } finally {
       await db.close();
     }
-  } catch (error2) {
-    console.error(
-      "\u274C Load failed:",
-      error2 instanceof Error ? error2.message : error2
-    );
+  } catch (err) {
+    error(`Load failed: ${err instanceof Error ? err.message : err}`);
     process.exit(1);
   }
 }
 
 // src/commands/scan.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
-import { join as join3, relative } from "path";
-import chalk3 from "chalk";
+import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
+import { join as join5, relative } from "path";
+import chalk5 from "chalk";
 import ora from "ora";
 import { parseFile, scanCommentToEntry } from "@mycontxt/core";
 import { glob } from "glob";
@@ -1319,9 +1577,9 @@ async function scanCommand(options = {}) {
       "**/*.lock",
       ".contxt/**"
     ];
-    const contxtIgnorePath = join3(process.cwd(), ".contxtignore");
-    if (existsSync4(contxtIgnorePath)) {
-      const contxtIgnore = readFileSync4(contxtIgnorePath, "utf-8").split("\n").filter((line) => line.trim() && !line.startsWith("#"));
+    const contxtIgnorePath = join5(process.cwd(), ".contxtignore");
+    if (existsSync5(contxtIgnorePath)) {
+      const contxtIgnore = readFileSync6(contxtIgnorePath, "utf-8").split("\n").filter((line) => line.trim() && !line.startsWith("#"));
       ignore.push(...contxtIgnore);
     }
     const searchPath = options.path || process.cwd();
@@ -1334,13 +1592,13 @@ async function scanCommand(options = {}) {
     spinner.text = `Scanning ${files.length} files...`;
     const allComments = [];
     for (const file of files) {
-      const content = readFileSync4(file, "utf-8");
+      const content = readFileSync6(file, "utf-8");
       const comments = parseFile(content, relative(process.cwd(), file));
       allComments.push(...comments);
     }
     spinner.succeed(`Found ${allComments.length} tagged comments across ${files.length} files`);
     if (allComments.length === 0) {
-      console.log(chalk3.gray("\nNo tagged comments found. Try adding @decision, @pattern, or @context tags to your code."));
+      console.log(chalk5.gray("\nNo tagged comments found. Try adding @decision, @pattern, or @context tags to your code."));
       return;
     }
     const existingEntries = await db.listEntries({
@@ -1370,50 +1628,50 @@ async function scanCommand(options = {}) {
     const staleEntries = Array.from(existingHashes.values());
     console.log("");
     if (newComments.length > 0) {
-      console.log(chalk3.bold("NEW"));
+      console.log(chalk5.bold("NEW"));
       for (const comment of newComments) {
         const icon = getTypeIcon(comment.tag);
         console.log(
-          `  ${chalk3.green("+")} ${icon} ${chalk3.bold(comment.title.substring(0, 50))}  ${chalk3.gray(comment.file + ":" + comment.line)}`
+          `  ${chalk5.green("+")} ${icon} ${chalk5.bold(comment.title.substring(0, 50))}  ${chalk5.gray(comment.file + ":" + comment.line)}`
         );
       }
       console.log("");
     }
     if (updatedComments.length > 0) {
-      console.log(chalk3.bold("UPDATED"));
+      console.log(chalk5.bold("UPDATED"));
       for (const comment of updatedComments) {
         const icon = getTypeIcon(comment.tag);
         console.log(
-          `  ${chalk3.yellow("~")} ${icon} ${chalk3.bold(comment.title.substring(0, 50))}  ${chalk3.gray(comment.file + ":" + comment.line)}`
+          `  ${chalk5.yellow("~")} ${icon} ${chalk5.bold(comment.title.substring(0, 50))}  ${chalk5.gray(comment.file + ":" + comment.line)}`
         );
       }
       console.log("");
     }
     if (unchangedComments.length > 0) {
-      console.log(chalk3.bold("UNCHANGED"));
+      console.log(chalk5.bold("UNCHANGED"));
       for (const comment of unchangedComments.slice(0, 3)) {
         const icon = getTypeIcon(comment.tag);
         console.log(
-          `  ${chalk3.gray("\xB7")} ${icon} ${chalk3.gray(comment.title.substring(0, 50))}  ${chalk3.gray(comment.file + ":" + comment.line)}`
+          `  ${chalk5.gray("\xB7")} ${icon} ${chalk5.gray(comment.title.substring(0, 50))}  ${chalk5.gray(comment.file + ":" + comment.line)}`
         );
       }
       if (unchangedComments.length > 3) {
-        console.log(chalk3.gray(`  ... and ${unchangedComments.length - 3} more`));
+        console.log(chalk5.gray(`  ... and ${unchangedComments.length - 3} more`));
       }
       console.log("");
     }
     if (staleEntries.length > 0) {
-      console.log(chalk3.bold("STALE (source comment removed)"));
+      console.log(chalk5.bold("STALE (source comment removed)"));
       for (const entry of staleEntries) {
         const icon = getTypeIcon(entry.type);
         console.log(
-          `  ${chalk3.red("?")} ${icon} ${chalk3.gray(entry.title.substring(0, 50))}  ${chalk3.gray("was: " + entry.metadata.file + ":" + entry.metadata.line)}`
+          `  ${chalk5.red("?")} ${icon} ${chalk5.gray(entry.title.substring(0, 50))}  ${chalk5.gray("was: " + entry.metadata.file + ":" + entry.metadata.line)}`
         );
       }
       console.log("");
     }
     if (options.dryRun) {
-      console.log(chalk3.yellow("Dry run - no changes saved."));
+      console.log(chalk5.yellow("Dry run - no changes saved."));
       return;
     }
     const toSave = [...newComments, ...updatedComments];
@@ -1447,30 +1705,30 @@ async function scanCommand(options = {}) {
       for (const entry of staleEntries) {
         await db.updateEntry(entry.id, { status: "stale" });
       }
-      console.log(chalk3.gray(`Marked ${staleEntries.length} entries as stale.`));
+      console.log(chalk5.gray(`Marked ${staleEntries.length} entries as stale.`));
     }
     if (!options.autoConfirm && toSave.length > 0) {
       console.log("");
-      console.log(chalk3.cyan(`Run ${chalk3.bold("contxt review")} to confirm drafts.`));
+      console.log(chalk5.cyan(`Run ${chalk5.bold("contxt review")} to confirm drafts.`));
     }
     await db.close();
   } catch (error2) {
     spinner.fail("Scan failed");
-    console.error(chalk3.red(error2 instanceof Error ? error2.message : String(error2)));
+    console.error(chalk5.red(error2 instanceof Error ? error2.message : String(error2)));
     process.exit(1);
   }
 }
 function getTypeIcon(type) {
   const icons = {
-    decision: chalk3.blue("DECISION"),
-    pattern: chalk3.magenta("PATTERN"),
-    context: chalk3.green("CONTEXT")
+    decision: chalk5.blue("DECISION"),
+    pattern: chalk5.magenta("PATTERN"),
+    context: chalk5.green("CONTEXT")
   };
   return icons[type] || type.toUpperCase();
 }
 
 // src/commands/review.ts
-import chalk4 from "chalk";
+import chalk6 from "chalk";
 import inquirer from "inquirer";
 import ora2 from "ora";
 async function reviewCommand(options = {}) {
@@ -1478,7 +1736,7 @@ async function reviewCommand(options = {}) {
     const db = await getProjectDb();
     const project = await db.getProjectByPath(process.cwd());
     if (!project) {
-      console.log(chalk4.red("Not a Contxt project. Run `contxt init` first."));
+      console.log(chalk6.red("Not a Contxt project. Run `contxt init` first."));
       return;
     }
     let drafts = await db.listEntries({
@@ -1493,14 +1751,14 @@ async function reviewCommand(options = {}) {
       });
     }
     if (drafts.length === 0) {
-      console.log(chalk4.green("\u2713 No drafts pending review"));
+      console.log(chalk6.green("\u2713 No drafts pending review"));
       return;
     }
     if (options.count) {
       console.log(`${drafts.length} drafts pending review`);
       return;
     }
-    console.log(chalk4.bold(`
+    console.log(chalk6.bold(`
 ${drafts.length} drafts pending review
 `));
     if (options.confirmAll) {
@@ -1535,7 +1793,7 @@ ${drafts.length} drafts pending review
     let discarded = 0;
     let skipped = 0;
     for (const draft of drafts) {
-      console.log(chalk4.gray("\u2500".repeat(50)));
+      console.log(chalk6.gray("\u2500".repeat(50)));
       console.log("");
       displayDraft(draft);
       console.log("");
@@ -1554,7 +1812,7 @@ ${drafts.length} drafts pending review
       ]);
       if (action === "confirm") {
         await db.updateEntry(draft.id, { status: "active" });
-        console.log(chalk4.green("\u2713 Confirmed"));
+        console.log(chalk6.green("\u2713 Confirmed"));
         confirmed++;
       } else if (action === "edit") {
         const edited = await editDraft(draft);
@@ -1564,28 +1822,28 @@ ${drafts.length} drafts pending review
           metadata: edited.metadata,
           status: "active"
         });
-        console.log(chalk4.green("\u2713 Edited and confirmed"));
+        console.log(chalk6.green("\u2713 Edited and confirmed"));
         confirmed++;
       } else if (action === "discard") {
         await db.deleteEntry(draft.id);
-        console.log(chalk4.red("\u2717 Discarded"));
+        console.log(chalk6.red("\u2717 Discarded"));
         discarded++;
       } else {
-        console.log(chalk4.gray("\u25CB Skipped"));
+        console.log(chalk6.gray("\u25CB Skipped"));
         skipped++;
       }
       console.log("");
     }
-    console.log(chalk4.gray("\u2500".repeat(50)));
+    console.log(chalk6.gray("\u2500".repeat(50)));
     console.log("");
-    console.log(chalk4.bold("Review complete"));
-    console.log(`  ${chalk4.green(confirmed)} confirmed`);
-    console.log(`  ${chalk4.red(discarded)} discarded`);
-    console.log(`  ${chalk4.gray(skipped)} skipped`);
+    console.log(chalk6.bold("Review complete"));
+    console.log(`  ${chalk6.green(confirmed)} confirmed`);
+    console.log(`  ${chalk6.red(discarded)} discarded`);
+    console.log(`  ${chalk6.gray(skipped)} skipped`);
     console.log("");
     await db.close();
   } catch (error2) {
-    console.error(chalk4.red(error2 instanceof Error ? error2.message : String(error2)));
+    console.error(chalk6.red(error2 instanceof Error ? error2.message : String(error2)));
     process.exit(1);
   }
 }
@@ -1594,28 +1852,28 @@ function displayDraft(draft) {
   const source = draft.metadata.source || "unknown";
   const file = draft.metadata.file ? ` \xB7 ${draft.metadata.file}:${draft.metadata.line}` : "";
   const timeAgo = getTimeAgo(draft.createdAt);
-  console.log(`  ${icon}  ${chalk4.bold(draft.title)}`);
-  console.log(`  ${chalk4.gray(`Source: ${source}${file} \xB7 ${timeAgo}`)}`);
+  console.log(`  ${icon}  ${chalk6.bold(draft.title)}`);
+  console.log(`  ${chalk6.gray(`Source: ${source}${file} \xB7 ${timeAgo}`)}`);
   const contentPreview = draft.content.split("\n")[0].substring(0, 80);
   if (contentPreview) {
-    console.log(`  ${chalk4.gray(contentPreview)}${draft.content.length > 80 ? "..." : ""}`);
+    console.log(`  ${chalk6.gray(contentPreview)}${draft.content.length > 80 ? "..." : ""}`);
   }
   if (draft.type === "decision") {
     if (draft.metadata.rationale) {
-      console.log(`  ${chalk4.dim("Rationale:")} ${draft.metadata.rationale.substring(0, 60)}...`);
+      console.log(`  ${chalk6.dim("Rationale:")} ${draft.metadata.rationale.substring(0, 60)}...`);
     }
     if (draft.metadata.alternatives) {
-      console.log(`  ${chalk4.dim("Alternatives:")} ${draft.metadata.alternatives}`);
+      console.log(`  ${chalk6.dim("Alternatives:")} ${draft.metadata.alternatives}`);
     }
   }
   if (draft.type === "pattern") {
     if (draft.metadata.when) {
-      console.log(`  ${chalk4.dim("When:")} ${draft.metadata.when}`);
+      console.log(`  ${chalk6.dim("When:")} ${draft.metadata.when}`);
     }
   }
 }
 async function editDraft(draft) {
-  console.log(chalk4.cyan("\nEdit mode (press Enter to keep current value):\n"));
+  console.log(chalk6.cyan("\nEdit mode (press Enter to keep current value):\n"));
   const { title, content } = await inquirer.prompt([
     {
       type: "input",
@@ -1638,11 +1896,11 @@ async function editDraft(draft) {
 }
 function getTypeIcon2(type) {
   const icons = {
-    decision: chalk4.blue("DECISION"),
-    pattern: chalk4.magenta("PATTERN"),
-    context: chalk4.green("CONTEXT"),
-    document: chalk4.yellow("DOCUMENT"),
-    session: chalk4.cyan("SESSION")
+    decision: chalk6.blue("DECISION"),
+    pattern: chalk6.magenta("PATTERN"),
+    context: chalk6.green("CONTEXT"),
+    document: chalk6.yellow("DOCUMENT"),
+    session: chalk6.cyan("SESSION")
   };
   return icons[type] || type.toUpperCase();
 }
@@ -1655,9 +1913,9 @@ function getTimeAgo(date) {
 }
 
 // src/commands/rules.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "fs";
-import { join as join4 } from "path";
-import chalk5 from "chalk";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import chalk7 from "chalk";
 import ora3 from "ora";
 import { parseRulesFile, generateRulesFile } from "@mycontxt/core";
 async function syncCommand2(options = {}) {
@@ -1669,12 +1927,12 @@ async function syncCommand2(options = {}) {
       spinner.fail("Not a Contxt project. Run `contxt init` first.");
       return;
     }
-    const rulesPath = join4(process.cwd(), ".contxt", "rules.md");
-    if (!existsSync5(rulesPath)) {
+    const rulesPath = join6(process.cwd(), ".contxt", "rules.md");
+    if (!existsSync6(rulesPath)) {
       spinner.fail("No rules.md file found. Run `contxt rules generate` to create one.");
       return;
     }
-    const content = readFileSync5(rulesPath, "utf-8");
+    const content = readFileSync7(rulesPath, "utf-8");
     const parsed = parseRulesFile(content);
     spinner.text = "Processing entries...";
     let added = 0;
@@ -1801,7 +2059,7 @@ async function syncCommand2(options = {}) {
     await db.close();
   } catch (error2) {
     spinner.fail("Sync failed");
-    console.error(chalk5.red(error2 instanceof Error ? error2.message : String(error2)));
+    console.error(chalk7.red(error2 instanceof Error ? error2.message : String(error2)));
     process.exit(1);
   }
 }
@@ -1814,8 +2072,8 @@ async function generateCommand(options = {}) {
       spinner.fail("Not a Contxt project. Run `contxt init` first.");
       return;
     }
-    const rulesPath = join4(process.cwd(), ".contxt", "rules.md");
-    if (existsSync5(rulesPath) && !options.force) {
+    const rulesPath = join6(process.cwd(), ".contxt", "rules.md");
+    if (existsSync6(rulesPath) && !options.force) {
       spinner.fail("rules.md already exists. Use --force to overwrite.");
       return;
     }
@@ -1852,15 +2110,15 @@ async function generateCommand(options = {}) {
     if (options.dryRun) {
       spinner.succeed("Generated rules.md (dry run):");
       console.log("");
-      console.log(chalk5.gray(rulesContent));
+      console.log(chalk7.gray(rulesContent));
     } else {
-      writeFileSync3(rulesPath, rulesContent, "utf-8");
+      writeFileSync4(rulesPath, rulesContent, "utf-8");
       spinner.succeed(`Generated ${rulesPath}`);
     }
     await db.close();
   } catch (error2) {
     spinner.fail("Generate failed");
-    console.error(chalk5.red(error2 instanceof Error ? error2.message : String(error2)));
+    console.error(chalk7.red(error2 instanceof Error ? error2.message : String(error2)));
     process.exit(1);
   }
 }
@@ -1873,12 +2131,12 @@ async function diffCommand() {
       spinner.fail("Not a Contxt project. Run `contxt init` first.");
       return;
     }
-    const rulesPath = join4(process.cwd(), ".contxt", "rules.md");
-    if (!existsSync5(rulesPath)) {
+    const rulesPath = join6(process.cwd(), ".contxt", "rules.md");
+    if (!existsSync6(rulesPath)) {
       spinner.fail("No rules.md file found.");
       return;
     }
-    const content = readFileSync5(rulesPath, "utf-8");
+    const content = readFileSync7(rulesPath, "utf-8");
     const parsed = parseRulesFile(content);
     const branch2 = await db.getActiveBranch(project.id);
     const allEntries = await db.listEntries({
@@ -1895,67 +2153,67 @@ async function diffCommand() {
     for (const decision2 of parsed.decisions) {
       const existing = existingByTitle.get(decision2.title);
       if (!existing) {
-        toAdd.push(`${chalk5.blue("DECISION")} ${decision2.title}`);
+        toAdd.push(`${chalk7.blue("DECISION")} ${decision2.title}`);
       } else if (existing.content !== decision2.content) {
-        toUpdate.push(`${chalk5.blue("DECISION")} ${decision2.title}`);
+        toUpdate.push(`${chalk7.blue("DECISION")} ${decision2.title}`);
       } else {
-        inSync.push(`${chalk5.blue("DECISION")} ${decision2.title}`);
+        inSync.push(`${chalk7.blue("DECISION")} ${decision2.title}`);
       }
     }
     for (const pattern2 of parsed.patterns) {
       const existing = existingByTitle.get(pattern2.title);
       if (!existing) {
-        toAdd.push(`${chalk5.magenta("PATTERN")} ${pattern2.title}`);
+        toAdd.push(`${chalk7.magenta("PATTERN")} ${pattern2.title}`);
       } else if (existing.content !== pattern2.content) {
-        toUpdate.push(`${chalk5.magenta("PATTERN")} ${pattern2.title}`);
+        toUpdate.push(`${chalk7.magenta("PATTERN")} ${pattern2.title}`);
       } else {
-        inSync.push(`${chalk5.magenta("PATTERN")} ${pattern2.title}`);
+        inSync.push(`${chalk7.magenta("PATTERN")} ${pattern2.title}`);
       }
     }
     for (const doc2 of parsed.documents) {
       const existing = existingByTitle.get(doc2.title);
       if (!existing) {
-        toAdd.push(`${chalk5.cyan("DOCUMENT")} ${doc2.title}`);
+        toAdd.push(`${chalk7.cyan("DOCUMENT")} ${doc2.title}`);
       } else if (existing.content !== doc2.content) {
-        toUpdate.push(`${chalk5.cyan("DOCUMENT")} ${doc2.title}`);
+        toUpdate.push(`${chalk7.cyan("DOCUMENT")} ${doc2.title}`);
       } else {
-        inSync.push(`${chalk5.cyan("DOCUMENT")} ${doc2.title}`);
+        inSync.push(`${chalk7.cyan("DOCUMENT")} ${doc2.title}`);
       }
     }
     console.log("");
     if (toAdd.length > 0) {
-      console.log(chalk5.bold("TO ADD (in rules.md, not in memory):"));
+      console.log(chalk7.bold("TO ADD (in rules.md, not in memory):"));
       for (const item of toAdd) {
-        console.log(`  ${chalk5.green("+")} ${item}`);
+        console.log(`  ${chalk7.green("+")} ${item}`);
       }
       console.log("");
     }
     if (toUpdate.length > 0) {
-      console.log(chalk5.bold("TO UPDATE (content differs):"));
+      console.log(chalk7.bold("TO UPDATE (content differs):"));
       for (const item of toUpdate) {
-        console.log(`  ${chalk5.yellow("~")} ${item}`);
+        console.log(`  ${chalk7.yellow("~")} ${item}`);
       }
       console.log("");
     }
     if (inSync.length > 0) {
-      console.log(chalk5.bold("IN SYNC:"));
+      console.log(chalk7.bold("IN SYNC:"));
       for (const item of inSync.slice(0, 5)) {
-        console.log(`  ${chalk5.gray("\xB7")} ${chalk5.gray(item)}`);
+        console.log(`  ${chalk7.gray("\xB7")} ${chalk7.gray(item)}`);
       }
       if (inSync.length > 5) {
-        console.log(chalk5.gray(`  ... and ${inSync.length - 5} more`));
+        console.log(chalk7.gray(`  ... and ${inSync.length - 5} more`));
       }
       console.log("");
     }
     if (toAdd.length > 0 || toUpdate.length > 0) {
-      console.log(chalk5.cyan(`Run ${chalk5.bold("contxt rules sync")} to apply changes.`));
+      console.log(chalk7.cyan(`Run ${chalk7.bold("contxt rules sync")} to apply changes.`));
     } else {
-      console.log(chalk5.green("\u2713 Everything in sync!"));
+      console.log(chalk7.green("\u2713 Everything in sync!"));
     }
     await db.close();
   } catch (error2) {
     spinner.fail("Diff failed");
-    console.error(chalk5.red(error2 instanceof Error ? error2.message : String(error2)));
+    console.error(chalk7.red(error2 instanceof Error ? error2.message : String(error2)));
     process.exit(1);
   }
 }
@@ -1966,9 +2224,9 @@ var rulesCommand = {
 };
 
 // src/commands/capture.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6, readdirSync } from "fs";
-import { join as join5, basename as basename2 } from "path";
-import chalk6 from "chalk";
+import { readFileSync as readFileSync8, existsSync as existsSync7, readdirSync } from "fs";
+import { join as join7, basename as basename2 } from "path";
+import chalk8 from "chalk";
 import ora4 from "ora";
 async function captureCommand(options = {}) {
   const spinner = ora4("Scanning project files...").start();
@@ -2006,24 +2264,24 @@ async function captureCommand(options = {}) {
     }
     spinner.succeed(`Found ${entries.length} entries across ${sources.length} source(s)`);
     if (entries.length === 0) {
-      console.log(chalk6.gray("\\nNo entries found to import."));
+      console.log(chalk8.gray("\\nNo entries found to import."));
       return;
     }
     console.log("");
     const grouped = groupBy(entries, "source");
     for (const [source, items] of Object.entries(grouped)) {
-      console.log(chalk6.bold(`${source.toUpperCase()} (${items.length})`));
+      console.log(chalk8.bold(`${source.toUpperCase()} (${items.length})`));
       for (const item of items.slice(0, 3)) {
         const icon = getTypeIcon3(item.type);
-        console.log(`  ${icon} ${chalk6.bold(item.title.substring(0, 60))}`);
+        console.log(`  ${icon} ${chalk8.bold(item.title.substring(0, 60))}`);
       }
       if (items.length > 3) {
-        console.log(chalk6.gray(`  ... and ${items.length - 3} more`));
+        console.log(chalk8.gray(`  ... and ${items.length - 3} more`));
       }
       console.log("");
     }
     if (options.dryRun) {
-      console.log(chalk6.yellow("Dry run - no entries saved."));
+      console.log(chalk8.yellow("Dry run - no entries saved."));
       return;
     }
     const saveSpinner = ora4("Saving entries...").start();
@@ -2047,20 +2305,20 @@ async function captureCommand(options = {}) {
     );
     if (!options.autoConfirm) {
       console.log("");
-      console.log(chalk6.cyan(`Run ${chalk6.bold("contxt review")} to confirm drafts.`));
+      console.log(chalk8.cyan(`Run ${chalk8.bold("contxt review")} to confirm drafts.`));
     }
     await db.close();
   } catch (error2) {
     spinner.fail("Import failed");
-    console.error(chalk6.red(error2 instanceof Error ? error2.message : String(error2)));
+    console.error(chalk8.red(error2 instanceof Error ? error2.message : String(error2)));
     process.exit(1);
   }
 }
 function importReadme() {
-  const readmePath = join5(process.cwd(), "README.md");
-  if (!existsSync6(readmePath)) return [];
+  const readmePath = join7(process.cwd(), "README.md");
+  if (!existsSync7(readmePath)) return [];
   try {
-    const content = readFileSync6(readmePath, "utf-8");
+    const content = readFileSync8(readmePath, "utf-8");
     const lines = content.split("\\n");
     const entries = [];
     let currentSection = null;
@@ -2107,10 +2365,10 @@ function importReadme() {
 }
 function importCursor() {
   const entries = [];
-  const cursorrulesPath = join5(process.cwd(), ".cursorrules");
-  if (existsSync6(cursorrulesPath)) {
+  const cursorrulesPath = join7(process.cwd(), ".cursorrules");
+  if (existsSync7(cursorrulesPath)) {
     try {
-      const content = readFileSync6(cursorrulesPath, "utf-8").trim();
+      const content = readFileSync8(cursorrulesPath, "utf-8").trim();
       if (content.length > 0) {
         entries.push({
           type: "document",
@@ -2123,10 +2381,10 @@ function importCursor() {
     } catch {
     }
   }
-  const cursorRulesPath = join5(process.cwd(), ".cursor", "rules");
-  if (existsSync6(cursorRulesPath)) {
+  const cursorRulesPath = join7(process.cwd(), ".cursor", "rules");
+  if (existsSync7(cursorRulesPath)) {
     try {
-      const content = readFileSync6(cursorRulesPath, "utf-8").trim();
+      const content = readFileSync8(cursorRulesPath, "utf-8").trim();
       if (content.length > 0) {
         entries.push({
           type: "document",
@@ -2143,10 +2401,10 @@ function importCursor() {
 }
 function importClaude() {
   const entries = [];
-  const claudePath = join5(process.cwd(), ".claude", "CLAUDE.md");
-  if (existsSync6(claudePath)) {
+  const claudePath = join7(process.cwd(), ".claude", "CLAUDE.md");
+  if (existsSync7(claudePath)) {
     try {
-      const content = readFileSync6(claudePath, "utf-8");
+      const content = readFileSync8(claudePath, "utf-8");
       const lines = content.split("\\n");
       let currentSection = null;
       let currentContent = [];
@@ -2193,17 +2451,17 @@ function importClaude() {
 function importADR() {
   const entries = [];
   const adrDirs = [
-    join5(process.cwd(), "docs", "adr"),
-    join5(process.cwd(), "docs", "architecture"),
-    join5(process.cwd(), "adr")
+    join7(process.cwd(), "docs", "adr"),
+    join7(process.cwd(), "docs", "architecture"),
+    join7(process.cwd(), "adr")
   ];
   for (const adrDir of adrDirs) {
-    if (!existsSync6(adrDir)) continue;
+    if (!existsSync7(adrDir)) continue;
     try {
-      const files = readdirSync(adrDir).filter((f) => f.endsWith(".md")).map((f) => join5(adrDir, f));
+      const files = readdirSync(adrDir).filter((f) => f.endsWith(".md")).map((f) => join7(adrDir, f));
       for (const file of files) {
         try {
-          const content = readFileSync6(file, "utf-8");
+          const content = readFileSync8(file, "utf-8");
           const title = extractADRTitle(content, basename2(file, ".md"));
           entries.push({
             type: "decision",
@@ -2265,10 +2523,10 @@ function importCommits(limit) {
 }
 function importPackageFiles() {
   const entries = [];
-  const packagePath = join5(process.cwd(), "package.json");
-  if (existsSync6(packagePath)) {
+  const packagePath = join7(process.cwd(), "package.json");
+  if (existsSync7(packagePath)) {
     try {
-      const pkg = JSON.parse(readFileSync6(packagePath, "utf-8"));
+      const pkg = JSON.parse(readFileSync8(packagePath, "utf-8"));
       if (pkg.description) {
         entries.push({
           type: "document",
@@ -2294,10 +2552,10 @@ function importPackageFiles() {
     } catch {
     }
   }
-  const requirementsPath = join5(process.cwd(), "requirements.txt");
-  if (existsSync6(requirementsPath)) {
+  const requirementsPath = join7(process.cwd(), "requirements.txt");
+  if (existsSync7(requirementsPath)) {
     try {
-      const content = readFileSync6(requirementsPath, "utf-8");
+      const content = readFileSync8(requirementsPath, "utf-8");
       const packages = content.split("\\n").filter((line) => line.trim() && !line.startsWith("#")).map((line) => line.split("==")[0].split(">=")[0].trim());
       if (packages.length > 0) {
         entries.push({
@@ -2311,10 +2569,10 @@ function importPackageFiles() {
     } catch {
     }
   }
-  const cargoPath = join5(process.cwd(), "Cargo.toml");
-  if (existsSync6(cargoPath)) {
+  const cargoPath = join7(process.cwd(), "Cargo.toml");
+  if (existsSync7(cargoPath)) {
     try {
-      const content = readFileSync6(cargoPath, "utf-8");
+      const content = readFileSync8(cargoPath, "utf-8");
       const nameMatch = content.match(/name\\s*=\\s*"([^"]+)"/);
       const descMatch = content.match(/description\\s*=\\s*"([^"]+)"/);
       if (descMatch) {
@@ -2341,19 +2599,19 @@ function groupBy(arr, key) {
 }
 function getTypeIcon3(type) {
   const icons = {
-    decision: chalk6.blue("DECISION"),
-    pattern: chalk6.magenta("PATTERN"),
-    context: chalk6.green("CONTEXT"),
-    document: chalk6.cyan("DOCUMENT"),
-    session: chalk6.yellow("SESSION")
+    decision: chalk8.blue("DECISION"),
+    pattern: chalk8.magenta("PATTERN"),
+    context: chalk8.green("CONTEXT"),
+    document: chalk8.cyan("DOCUMENT"),
+    session: chalk8.yellow("SESSION")
   };
   return icons[type] || type.toUpperCase();
 }
 
 // src/commands/hook.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync8, chmodSync, mkdirSync as mkdirSync3 } from "fs";
-import { join as join7 } from "path";
-import chalk7 from "chalk";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync9, chmodSync as chmodSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join9 } from "path";
+import chalk9 from "chalk";
 
 // src/hooks/post-commit.ts
 import { execSync } from "child_process";
@@ -2441,8 +2699,8 @@ function stripConventionalPrefix(msg) {
 
 // src/hooks/pre-push.ts
 import { execSync as execSync2 } from "child_process";
-import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
 async function runPrePush() {
   try {
     const db = await getProjectDb();
@@ -2494,10 +2752,10 @@ async function runPrePush() {
       `contxt: session updated \u2014 ${commitCount} commit${commitCount !== 1 ? "s" : ""}, ${changedFiles.length} files changed
 `
     );
-    const configPath = join6(process.cwd(), ".contxt", "config.json");
-    if (existsSync7(configPath)) {
+    const configPath = join8(process.cwd(), ".contxt", "config.json");
+    if (existsSync8(configPath)) {
       try {
-        const config = JSON.parse(readFileSync7(configPath, "utf-8"));
+        const config = JSON.parse(readFileSync9(configPath, "utf-8"));
         if (config.hooks?.auto_push_on_push) {
           process.stdout.write("contxt: syncing to cloud...\n");
           execSync2("contxt push --quiet 2>/dev/null", {
@@ -2545,7 +2803,7 @@ async function runPostCheckout() {
 }
 
 // src/hooks/prepare-commit-msg.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
 async function runPrepareCommitMsg() {
   try {
     const commitMsgFile = process.argv[4];
@@ -2586,45 +2844,45 @@ async function runPrepareCommitMsg() {
       lines.push(`# ${draftCount} drafts pending \u2014 run \`contxt review\``);
     }
     lines.push("#");
-    const existing = readFileSync8(commitMsgFile, "utf-8");
-    writeFileSync4(commitMsgFile, existing + lines.join("\n") + "\n", "utf-8");
+    const existing = readFileSync10(commitMsgFile, "utf-8");
+    writeFileSync5(commitMsgFile, existing + lines.join("\n") + "\n", "utf-8");
     await db.close();
   } catch {
   }
 }
 
 // src/commands/hook.ts
-var CONTXT_BLOCK_START = "# --- contxt hook start ---";
-var CONTXT_BLOCK_END = "# --- contxt hook end ---";
-var ALL_HOOKS = ["post-commit", "pre-push", "post-checkout", "prepare-commit-msg"];
+var CONTXT_BLOCK_START2 = "# --- contxt hook start ---";
+var CONTXT_BLOCK_END2 = "# --- contxt hook end ---";
+var ALL_HOOKS2 = ["post-commit", "pre-push", "post-checkout", "prepare-commit-msg"];
 async function installCommand(options = {}) {
-  const gitHooksDir = join7(process.cwd(), ".git", "hooks");
-  if (!existsSync8(join7(process.cwd(), ".git"))) {
-    console.error(chalk7.red("Not a git repository."));
+  const gitHooksDir = join9(process.cwd(), ".git", "hooks");
+  if (!existsSync9(join9(process.cwd(), ".git"))) {
+    console.error(chalk9.red("Not a git repository."));
     process.exit(1);
   }
   mkdirSync3(gitHooksDir, { recursive: true });
-  const hooksToInstall = options.hooks ? options.hooks.split(",").map((h) => h.trim()) : [...ALL_HOOKS];
+  const hooksToInstall = options.hooks ? options.hooks.split(",").map((h) => h.trim()) : [...ALL_HOOKS2];
   let installed = 0;
   let updated = 0;
   for (const hookName of hooksToInstall) {
-    const hookPath = join7(gitHooksDir, hookName);
+    const hookPath = join9(gitHooksDir, hookName);
     const contxtLine = `contxt hook run ${hookName} "$@"`;
-    const contxtBlock = `${CONTXT_BLOCK_START}
+    const contxtBlock = `${CONTXT_BLOCK_START2}
 ${contxtLine}
-${CONTXT_BLOCK_END}`;
-    if (existsSync8(hookPath)) {
-      const content = readFileSync9(hookPath, "utf-8");
-      if (content.includes(CONTXT_BLOCK_START)) {
+${CONTXT_BLOCK_END2}`;
+    if (existsSync9(hookPath)) {
+      const content = readFileSync11(hookPath, "utf-8");
+      if (content.includes(CONTXT_BLOCK_START2)) {
         const updated_content = content.replace(
-          new RegExp(`${escapeRegex(CONTXT_BLOCK_START)}[\\s\\S]*?${escapeRegex(CONTXT_BLOCK_END)}`),
+          new RegExp(`${escapeRegex(CONTXT_BLOCK_START2)}[\\s\\S]*?${escapeRegex(CONTXT_BLOCK_END2)}`),
           contxtBlock
         );
-        writeFileSync5(hookPath, updated_content, "utf-8");
+        writeFileSync6(hookPath, updated_content, "utf-8");
         updated++;
       } else {
         const newContent = content.trimEnd() + "\n\n" + contxtBlock + "\n";
-        writeFileSync5(hookPath, newContent, "utf-8");
+        writeFileSync6(hookPath, newContent, "utf-8");
         installed++;
       }
     } else {
@@ -2632,79 +2890,79 @@ ${CONTXT_BLOCK_END}`;
 
 ${contxtBlock}
 `;
-      writeFileSync5(hookPath, newContent, "utf-8");
+      writeFileSync6(hookPath, newContent, "utf-8");
       installed++;
     }
-    chmodSync(hookPath, "755");
-    console.log(chalk7.green("\u2713"), `${hookName}`);
+    chmodSync2(hookPath, "755");
+    console.log(chalk9.green("\u2713"), `${hookName}`);
   }
   console.log("");
-  if (installed > 0) console.log(chalk7.green(`Installed ${installed} hook${installed !== 1 ? "s" : ""}.`));
-  if (updated > 0) console.log(chalk7.yellow(`Updated ${updated} existing hook${updated !== 1 ? "s" : ""}.`));
+  if (installed > 0) console.log(chalk9.green(`Installed ${installed} hook${installed !== 1 ? "s" : ""}.`));
+  if (updated > 0) console.log(chalk9.yellow(`Updated ${updated} existing hook${updated !== 1 ? "s" : ""}.`));
   console.log("");
-  console.log(chalk7.gray("Hooks will capture context from your git workflow automatically."));
+  console.log(chalk9.gray("Hooks will capture context from your git workflow automatically."));
 }
 async function uninstallCommand(options = {}) {
-  const gitHooksDir = join7(process.cwd(), ".git", "hooks");
-  if (!existsSync8(join7(process.cwd(), ".git"))) {
-    console.error(chalk7.red("Not a git repository."));
+  const gitHooksDir = join9(process.cwd(), ".git", "hooks");
+  if (!existsSync9(join9(process.cwd(), ".git"))) {
+    console.error(chalk9.red("Not a git repository."));
     process.exit(1);
   }
-  const hooksToRemove = options.hooks ? options.hooks.split(",").map((h) => h.trim()) : [...ALL_HOOKS];
+  const hooksToRemove = options.hooks ? options.hooks.split(",").map((h) => h.trim()) : [...ALL_HOOKS2];
   let removed = 0;
   for (const hookName of hooksToRemove) {
-    const hookPath = join7(gitHooksDir, hookName);
-    if (!existsSync8(hookPath)) continue;
-    const content = readFileSync9(hookPath, "utf-8");
-    if (!content.includes(CONTXT_BLOCK_START)) continue;
+    const hookPath = join9(gitHooksDir, hookName);
+    if (!existsSync9(hookPath)) continue;
+    const content = readFileSync11(hookPath, "utf-8");
+    if (!content.includes(CONTXT_BLOCK_START2)) continue;
     const cleaned = content.replace(
-      new RegExp(`\\n*${escapeRegex(CONTXT_BLOCK_START)}[\\s\\S]*?${escapeRegex(CONTXT_BLOCK_END)}\\n*`),
+      new RegExp(`\\n*${escapeRegex(CONTXT_BLOCK_START2)}[\\s\\S]*?${escapeRegex(CONTXT_BLOCK_END2)}\\n*`),
       "\n"
     ).trim();
     if (cleaned === "#!/bin/sh" || cleaned === "") {
-      writeFileSync5(hookPath, "#!/bin/sh\n", "utf-8");
+      writeFileSync6(hookPath, "#!/bin/sh\n", "utf-8");
     } else {
-      writeFileSync5(hookPath, cleaned + "\n", "utf-8");
+      writeFileSync6(hookPath, cleaned + "\n", "utf-8");
     }
     removed++;
-    console.log(chalk7.gray("\u2717"), hookName);
+    console.log(chalk9.gray("\u2717"), hookName);
   }
   if (removed > 0) {
     console.log("");
-    console.log(chalk7.green(`Removed ${removed} hook${removed !== 1 ? "s" : ""}.`));
+    console.log(chalk9.green(`Removed ${removed} hook${removed !== 1 ? "s" : ""}.`));
   } else {
-    console.log(chalk7.gray("No Contxt hooks found to remove."));
+    console.log(chalk9.gray("No Contxt hooks found to remove."));
   }
 }
 async function statusCommand2() {
-  const gitHooksDir = join7(process.cwd(), ".git", "hooks");
-  if (!existsSync8(join7(process.cwd(), ".git"))) {
-    console.error(chalk7.red("Not a git repository."));
+  const gitHooksDir = join9(process.cwd(), ".git", "hooks");
+  if (!existsSync9(join9(process.cwd(), ".git"))) {
+    console.error(chalk9.red("Not a git repository."));
     process.exit(1);
   }
   console.log("");
-  console.log(chalk7.bold("Git Hook Status"));
+  console.log(chalk9.bold("Git Hook Status"));
   console.log("");
-  for (const hookName of ALL_HOOKS) {
-    const hookPath = join7(gitHooksDir, hookName);
-    const fileExists = existsSync8(hookPath);
+  for (const hookName of ALL_HOOKS2) {
+    const hookPath = join9(gitHooksDir, hookName);
+    const fileExists = existsSync9(hookPath);
     let isInstalled = false;
     if (fileExists) {
-      const content = readFileSync9(hookPath, "utf-8");
-      isInstalled = content.includes(CONTXT_BLOCK_START);
+      const content = readFileSync11(hookPath, "utf-8");
+      isInstalled = content.includes(CONTXT_BLOCK_START2);
     }
-    const statusIcon = isInstalled ? chalk7.green("\u2713") : chalk7.gray("\u25CB");
-    const label = isInstalled ? chalk7.green(hookName) : chalk7.gray(hookName);
-    const note = !fileExists ? chalk7.gray(" (no hook file)") : isInstalled ? chalk7.gray(" installed") : chalk7.yellow(" not installed");
+    const statusIcon = isInstalled ? chalk9.green("\u2713") : chalk9.gray("\u25CB");
+    const label = isInstalled ? chalk9.green(hookName) : chalk9.gray(hookName);
+    const note = !fileExists ? chalk9.gray(" (no hook file)") : isInstalled ? chalk9.gray(" installed") : chalk9.yellow(" not installed");
     console.log(`  ${statusIcon} ${label}${note}`);
   }
   console.log("");
-  const installedCount = ALL_HOOKS.filter((h) => {
-    const hookPath = join7(gitHooksDir, h);
-    return existsSync8(hookPath) && readFileSync9(hookPath, "utf-8").includes(CONTXT_BLOCK_START);
+  const installedCount = ALL_HOOKS2.filter((h) => {
+    const hookPath = join9(gitHooksDir, h);
+    return existsSync9(hookPath) && readFileSync11(hookPath, "utf-8").includes(CONTXT_BLOCK_START2);
   }).length;
   if (installedCount === 0) {
-    console.log(chalk7.cyan(`Run ${chalk7.bold("contxt hook install")} to enable automatic context capture.`));
+    console.log(chalk9.cyan(`Run ${chalk9.bold("contxt hook install")} to enable automatic context capture.`));
   }
 }
 async function runCommand(hookName) {
@@ -2735,12 +2993,14 @@ var hookCommand = {
 };
 
 // src/commands/watch.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync9, unlinkSync } from "fs";
-import { join as join8, relative as relative2 } from "path";
-import { spawn } from "child_process";
-import chalk8 from "chalk";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, existsSync as existsSync10, unlinkSync } from "fs";
+import { join as join10, relative as relative2 } from "path";
+import { spawn as spawn2 } from "child_process";
+import chalk10 from "chalk";
 import chokidar from "chokidar";
-import { parseFile as parseFile2, scanCommentToEntry as scanCommentToEntry2 } from "@mycontxt/core";
+import { parseFile as parseFile2, scanCommentToEntry as scanCommentToEntry2, SyncEngine as SyncEngine2 } from "@mycontxt/core";
+import { SQLiteDatabase as SQLiteDatabase7 } from "@mycontxt/adapters/sqlite";
+import { SupabaseDatabase as SupabaseDatabase4 } from "@mycontxt/adapters/supabase";
 var PID_FILE = ".contxt/.watch.pid";
 var LOG_FILE = ".contxt/watch.log";
 var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
@@ -2752,59 +3012,59 @@ async function startCommand(options = {}) {
   return runWatcher();
 }
 async function stopCommand() {
-  const pidFile = join8(process.cwd(), PID_FILE);
-  if (!existsSync9(pidFile)) {
-    console.log(chalk8.gray("No watch daemon running."));
+  const pidFile = join10(process.cwd(), PID_FILE);
+  if (!existsSync10(pidFile)) {
+    console.log(chalk10.gray("No watch daemon running."));
     return;
   }
-  const pid = parseInt(readFileSync10(pidFile, "utf-8").trim(), 10);
+  const pid = parseInt(readFileSync12(pidFile, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     unlinkSync(pidFile);
-    console.log(chalk8.green("Watch daemon stopped."));
+    console.log(chalk10.green("Watch daemon stopped."));
   } catch {
-    console.log(chalk8.yellow("Daemon not found \u2014 removing stale PID file."));
+    console.log(chalk10.yellow("Daemon not found \u2014 removing stale PID file."));
     unlinkSync(pidFile);
   }
 }
 async function statusCommand3() {
-  const pidFile = join8(process.cwd(), PID_FILE);
-  if (!existsSync9(pidFile)) {
-    console.log(chalk8.gray("Watch daemon: not running"));
+  const pidFile = join10(process.cwd(), PID_FILE);
+  if (!existsSync10(pidFile)) {
+    console.log(chalk10.gray("Watch daemon: not running"));
     return;
   }
-  const pid = parseInt(readFileSync10(pidFile, "utf-8").trim(), 10);
+  const pid = parseInt(readFileSync12(pidFile, "utf-8").trim(), 10);
   try {
     process.kill(pid, 0);
-    console.log(chalk8.green(`Watch daemon: running (PID ${pid})`));
+    console.log(chalk10.green(`Watch daemon: running (PID ${pid})`));
   } catch {
-    console.log(chalk8.yellow("Watch daemon: stale PID file (process not found)"));
+    console.log(chalk10.yellow("Watch daemon: stale PID file (process not found)"));
     unlinkSync(pidFile);
   }
 }
 function startDaemon() {
-  const pidFile = join8(process.cwd(), PID_FILE);
-  if (existsSync9(pidFile)) {
-    const pid = parseInt(readFileSync10(pidFile, "utf-8").trim(), 10);
+  const pidFile = join10(process.cwd(), PID_FILE);
+  if (existsSync10(pidFile)) {
+    const pid = parseInt(readFileSync12(pidFile, "utf-8").trim(), 10);
     try {
       process.kill(pid, 0);
-      console.log(chalk8.yellow(`Watch daemon already running (PID ${pid}).`));
+      console.log(chalk10.yellow(`Watch daemon already running (PID ${pid}).`));
       return;
     } catch {
     }
   }
-  const logPath = join8(process.cwd(), LOG_FILE);
+  const logPath = join10(process.cwd(), LOG_FILE);
   const logStream = __require("fs").openSync(logPath, "a");
-  const child = spawn(process.execPath, [process.argv[1], "watch"], {
+  const child = spawn2(process.execPath, [process.argv[1], "watch"], {
     env: { ...process.env, CONTXT_WATCH_DAEMON: "1" },
     detached: true,
     stdio: ["ignore", logStream, logStream],
     cwd: process.cwd()
   });
   child.unref();
-  writeFileSync6(pidFile, String(child.pid), "utf-8");
-  console.log(chalk8.green(`Watch daemon started (PID ${child.pid}).`));
-  console.log(chalk8.gray(`Logs: ${logPath}`));
+  writeFileSync7(pidFile, String(child.pid), "utf-8");
+  console.log(chalk10.green(`Watch daemon started (PID ${child.pid}).`));
+  console.log(chalk10.gray(`Logs: ${logPath}`));
 }
 async function runWatcher() {
   const cwd = process.cwd();
@@ -2812,12 +3072,12 @@ async function runWatcher() {
   const db = await getProjectDb(cwd);
   const project = await db.getProjectByPath(cwd);
   if (!project) {
-    if (!isDaemon) console.error(chalk8.red("Not a Contxt project."));
+    if (!isDaemon) console.error(chalk10.red("Not a Contxt project."));
     return;
   }
   const branch2 = await db.getActiveBranch(project.id);
   if (!isDaemon) {
-    console.log(chalk8.bold(`contxt watch`) + ` \u2014 monitoring ${project.name} (${branch2})`);
+    console.log(chalk10.bold(`contxt watch`) + ` \u2014 monitoring ${project.name} (${branch2})`);
     console.log("");
   }
   const pendingFiles = /* @__PURE__ */ new Set();
@@ -2854,9 +3114,9 @@ async function runWatcher() {
     usePolling: false,
     interval: 1e3
   });
-  const rulesPath = join8(cwd, ".contxt", "rules.md");
+  const rulesPath = join10(cwd, ".contxt", "rules.md");
   const rulesWatcher = chokidar.watch(rulesPath, { ignoreInitial: true });
-  const gitHeadPath = join8(cwd, ".git", "HEAD");
+  const gitHeadPath = join10(cwd, ".git", "HEAD");
   const gitWatcher = chokidar.watch(gitHeadPath, { ignoreInitial: true });
   watcher.on("change", (filePath) => {
     pendingFiles.add(filePath);
@@ -2872,7 +3132,7 @@ async function runWatcher() {
     log("rules", "rules.md changed \u2014 syncing...");
     try {
       const { parseRulesFile: parseRulesFile2 } = await import("@mycontxt/core");
-      const content = readFileSync10(rulesPath, "utf-8");
+      const content = readFileSync12(rulesPath, "utf-8");
       const parsed = parseRulesFile2(content);
       let synced = 0;
       const existing = await db.listEntries({ projectId: project.id, branch: branch2 });
@@ -2894,7 +3154,7 @@ async function runWatcher() {
   });
   gitWatcher.on("change", async () => {
     try {
-      const headContent = readFileSync10(gitHeadPath, "utf-8").trim();
+      const headContent = readFileSync12(gitHeadPath, "utf-8").trim();
       const branchMatch = headContent.match(/^ref: refs\/heads\/(.+)$/);
       if (!branchMatch) return;
       const newBranch = branchMatch[1];
@@ -2919,7 +3179,7 @@ async function runWatcher() {
       const activeCtx = entries.find((e) => e.status === "active");
       if (activeCtx) {
         const currentFiles = activeCtx.metadata.files || [];
-        const relFiles = files.map((f) => relative2(cwd, join8(cwd, f)));
+        const relFiles = files.map((f) => relative2(cwd, join10(cwd, f)));
         const merged = Array.from(/* @__PURE__ */ new Set([...currentFiles, ...relFiles])).slice(0, 30);
         await db.updateEntry(activeCtx.id, { metadata: { ...activeCtx.metadata, files: merged } });
       }
@@ -2928,9 +3188,9 @@ async function runWatcher() {
     let newDrafts = 0;
     for (const file of files) {
       try {
-        const absPath = join8(cwd, file);
-        if (!existsSync9(absPath)) continue;
-        const content = readFileSync10(absPath, "utf-8");
+        const absPath = join10(cwd, file);
+        if (!existsSync10(absPath)) continue;
+        const content = readFileSync12(absPath, "utf-8");
         const comments = parseFile2(content, file);
         if (comments.length === 0) continue;
         const existing = await db.listEntries({ projectId: project.id, branch: branch2 });
@@ -2946,6 +3206,25 @@ async function runWatcher() {
       }
     }
     log("files", `${files.length} file${files.length !== 1 ? "s" : ""} ${newDrafts > 0 ? `\xB7 +${newDrafts} draft${newDrafts !== 1 ? "s" : ""}` : ""}`);
+    try {
+      const freshProject = await db.getProjectByPath(cwd);
+      if (freshProject?.config.autoSync) {
+        const accessToken = getAccessToken();
+        if (accessToken) {
+          const supabaseConfig = getSupabaseConfig();
+          const dbPath = getDbPath();
+          const localDb = new SQLiteDatabase7(dbPath);
+          await localDb.initialize();
+          const remoteDb = new SupabaseDatabase4({ ...supabaseConfig, accessToken });
+          await remoteDb.initialize();
+          const syncEngine = new SyncEngine2(localDb, remoteDb);
+          const result = await syncEngine.push(freshProject.id, {});
+          await localDb.close();
+          log("sync", `pushed ${result.pushed} entr${result.pushed !== 1 ? "ies" : "y"} to cloud`);
+        }
+      }
+    } catch {
+    }
   }
   function scheduleFlush() {
     if (flushTimer) clearTimeout(flushTimer);
@@ -2972,10 +3251,10 @@ async function runWatcher() {
     const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
     const line = `${time}  ${type.padEnd(8)} ${message}`;
     if (!isDaemon) {
-      console.log(`  ${chalk8.gray(time)}  ${chalk8.cyan(type.padEnd(8))} ${message}`);
+      console.log(`  ${chalk10.gray(time)}  ${chalk10.cyan(type.padEnd(8))} ${message}`);
     } else {
       try {
-        __require("fs").appendFileSync(join8(cwd, LOG_FILE), line + "\n");
+        __require("fs").appendFileSync(join10(cwd, LOG_FILE), line + "\n");
       } catch {
       }
     }
@@ -2987,14 +3266,14 @@ async function runWatcher() {
     rulesWatcher.close();
     gitWatcher.close();
     await db.close();
-    const pidFile = join8(cwd, PID_FILE);
-    if (existsSync9(pidFile)) unlinkSync(pidFile);
+    const pidFile = join10(cwd, PID_FILE);
+    if (existsSync10(pidFile)) unlinkSync(pidFile);
     process.exit(0);
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
   if (!isDaemon) {
-    console.log(chalk8.gray("Watching for file changes. Ctrl+C to stop.\n"));
+    console.log(chalk10.gray("Watching for file changes. Ctrl+C to stop.\n"));
   }
 }
 var watchCommand = {