@workscribe/cli 1.9.0 → 1.10.0

package/dist/index.js

@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 
 // src/capture/index.ts
-var import_fs7 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 
 // src/db/index.ts
 var import_node_sqlite = require("node:sqlite");
@@ -43,6 +43,7 @@ var DEBUG_LOG_PATH = import_path.default.join(WORKSCRIBE_DIR, "debug.log");
 var EXPORTS_DIR = import_path.default.join(WORKSCRIBE_DIR, "exports");
 var PAUSE_FLAG_PATH = import_path.default.join(WORKSCRIBE_DIR, "paused");
 var WEEKLY_CACHE_DIR = import_path.default.join(WORKSCRIBE_DIR, "weekly-cache");
+var PROFILES_DIR = import_path.default.join(WORKSCRIBE_DIR, "profiles");
 
 // src/db/migrations/001_initial_schema.ts
 var initial_schema_default = {
@@ -85,8 +86,27 @@ var initial_schema_default = {
   `
 };
 
+// src/db/migrations/002_semantic_categories.ts
+var migration = {
+  version: 2,
+  description: "Rename granular categories to 13 universal semantic categories",
+  sql: `
+    UPDATE events SET category = 'shipping'        WHERE category IN ('code_commit','code_push','code_merge');
+    UPDATE events SET category = 'versioning'      WHERE category IN ('code_pull','branch_switch','code_stash','git_other');
+    UPDATE events SET category = 'building'        WHERE category = 'build';
+    UPDATE events SET category = 'running'         WHERE category IN ('server_run','script_run');
+    UPDATE events SET category = 'testing'         WHERE category = 'test_run';
+    UPDATE events SET category = 'linting'         WHERE category = 'lint_run';
+    UPDATE events SET category = 'dependencies'    WHERE category IN ('dependency_install','dependency_remove');
+    UPDATE events SET category = 'infrastructure'  WHERE category = 'infrastructure';
+    UPDATE events SET category = 'files'           WHERE category IN ('file_ops','environment');
+    UPDATE events SET category = 'exploring'       WHERE category IN ('code_search','code_read');
+  `
+};
+var semantic_categories_default = migration;
+
 // src/db/migrations/index.ts
-var MIGRATIONS = [initial_schema_default];
+var MIGRATIONS = [initial_schema_default, semantic_categories_default];
 
 // src/db/index.ts
 var _db = null;
@@ -123,13 +143,13 @@ function applyMigrations(db) {
   const applied = new Set(
     db.prepare("SELECT version FROM schema_migrations").all().map((row) => row.version)
   );
-  for (const migration of MIGRATIONS) {
-    if (applied.has(migration.version)) continue;
+  for (const migration2 of MIGRATIONS) {
+    if (applied.has(migration2.version)) continue;
     db.exec("BEGIN");
     try {
-      db.exec(migration.sql);
+      db.exec(migration2.sql);
       db.prepare("INSERT INTO schema_migrations (version, applied_at) VALUES ($version, datetime('now'))").run({
-        version: migration.version
+        version: migration2.version
       });
       db.exec("COMMIT");
     } catch (err) {
@@ -137,7 +157,7 @@ function applyMigrations(db) {
         db.exec("ROLLBACK");
       } catch {
       }
-      throw new Error(`Migration ${migration.version} (${migration.description}) failed: ${err.message}`);
+      throw new Error(`Migration ${migration2.version} (${migration2.description}) failed: ${err.message}`);
     }
   }
 }
@@ -232,6 +252,28 @@ function deleteEventsForDate(date) {
   const result = db.prepare(`DELETE FROM events WHERE date(captured_at, 'localtime') = $date`).run({ date });
   return result.changes;
 }
+function getOtherEventToolCounts(days) {
+  const db = getDb();
+  return db.prepare(
+    `SELECT json_extract(metadata, '$.tool') as tool, COUNT(*) as count
+       FROM events
+       WHERE category = 'other'
+         AND captured_at >= datetime('now', $offset)
+         AND json_extract(metadata, '$.tool') IS NOT NULL
+       GROUP BY tool
+       ORDER BY count DESC`
+  ).all({ offset: `-${days} days` });
+}
+function getRecentOtherRate(days) {
+  const db = getDb();
+  const row = db.prepare(
+    `SELECT COUNT(*) as total,
+              SUM(CASE WHEN category = 'other' THEN 1 ELSE 0 END) as otherCount
+       FROM events
+       WHERE captured_at >= datetime('now', $offset)`
+  ).get({ offset: `-${days} days` });
+  return row;
+}
 function clearSessionsForDate(date) {
   const db = getDb();
   db.prepare(
@@ -475,6 +517,240 @@ function loadAIToolRegistry() {
   return [...filteredBuiltins, ...userEntries];
 }
 
+// src/profiles/loader.ts
+var import_fs8 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+
+// src/config/index.ts
+var import_fs6 = __toESM(require("fs"));
+var DEFAULTS = {
+  ai: {
+    provider: "",
+    apiKey: "",
+    model: "",
+    baseUrl: ""
+  },
+  session: {
+    idleTimeout: 30
+  },
+  capture: {
+    ignore: ["cd", "ls", "ll", "la", "ls -la", "ls -l", "ls -a", "pwd", "clear", "exit", "history", "man"],
+    aiTools: true,
+    includeAiderPrompt: true,
+    profiles: []
+  },
+  redact: {
+    extra: []
+  },
+  summary: {
+    format: "markdown"
+  }
+};
+function readConfig() {
+  if (!import_fs6.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
+  try {
+    const raw = import_fs6.default.readFileSync(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(DEFAULTS, parsed);
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+function writeConfig(config) {
+  import_fs6.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  try {
+    import_fs6.default.chmodSync(CONFIG_PATH, 384);
+  } catch {
+  }
+}
+function getConfigValue(config, key) {
+  const parts = key.split(".");
+  let cur = config;
+  for (const part of parts) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function setConfigValue(config, key, value) {
+  const parts = key.split(".");
+  const result = JSON.parse(JSON.stringify(config));
+  let cur = result;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (cur[part] == null || typeof cur[part] !== "object") {
+      cur[part] = {};
+    }
+    cur = cur[part];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (value === "true") cur[lastKey] = true;
+  else if (value === "false") cur[lastKey] = false;
+  else if (!isNaN(Number(value))) cur[lastKey] = Number(value);
+  else cur[lastKey] = value;
+  return result;
+}
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const val = overrides[key];
+    if (val !== null && typeof val === "object" && !Array.isArray(val) && typeof defaults[key] === "object") {
+      result[key] = deepMerge(defaults[key], val);
+    } else if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+// src/profiles/schema.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isValidRule(rule) {
+  if (!rule || typeof rule !== "object") return false;
+  const { pattern, category } = rule;
+  return isNonEmptyString(pattern) && isNonEmptyString(category);
+}
+function isValidProfile(candidate) {
+  if (!candidate || typeof candidate !== "object") return false;
+  const { name, displayName, version, rules } = candidate;
+  if (!isNonEmptyString(name) || !isNonEmptyString(displayName) || !isNonEmptyString(version)) return false;
+  if (!Array.isArray(rules)) return false;
+  return rules.every(isValidRule);
+}
+function isValidManifest(m) {
+  return Array.isArray(m) && m.every((e) => e && typeof e === "object" && typeof e.name === "string");
+}
+
+// src/profiles/fetcher.ts
+var import_fs7 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var REGISTRY_BASE = "https://raw.githubusercontent.com/workscribe/profiles/main";
+function manifestCachePath() {
+  return import_path5.default.join(PROFILES_DIR, "manifest.json");
+}
+async function fetchManifest() {
+  const response = await fetch(`${REGISTRY_BASE}/manifest.json`);
+  if (!response.ok) throw new Error(`Registry unreachable (${response.status})`);
+  const data = await response.json();
+  if (!isValidManifest(data)) throw new Error("Manifest format unrecognised");
+  return data;
+}
+async function fetchProfile(name) {
+  const response = await fetch(`${REGISTRY_BASE}/${name}.json`);
+  if (response.status === 404) throw new Error(`Profile "${name}" not found in registry`);
+  if (!response.ok) throw new Error(`Registry unreachable (${response.status})`);
+  const data = await response.json();
+  if (!isValidProfile(data)) throw new Error(`Profile "${name}" failed schema validation`);
+  return data;
+}
+async function installProfile(name) {
+  ensureProfilesDir();
+  const profile = await fetchProfile(name);
+  const dest = import_path5.default.join(PROFILES_DIR, `${name}.json`);
+  import_fs7.default.writeFileSync(dest, JSON.stringify(profile, null, 2), { encoding: "utf-8", mode: 384 });
+  debugLog("profiles", `Installed profile "${name}" to ${dest}`);
+}
+async function cacheManifest() {
+  ensureProfilesDir();
+  const manifest = await fetchManifest();
+  import_fs7.default.writeFileSync(manifestCachePath(), JSON.stringify(manifest, null, 2), { encoding: "utf-8", mode: 384 });
+  return manifest;
+}
+function readCachedManifest() {
+  if (!import_fs7.default.existsSync(manifestCachePath())) return null;
+  try {
+    const data = JSON.parse(import_fs7.default.readFileSync(manifestCachePath(), "utf-8"));
+    return isValidManifest(data) ? data : null;
+  } catch {
+    return null;
+  }
+}
+function ensureProfilesDir() {
+  if (!import_fs7.default.existsSync(PROFILES_DIR)) {
+    import_fs7.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
+  }
+}
+
+// src/profiles/loader.ts
+function compileRule(profileName, rule) {
+  let regex;
+  try {
+    regex = new RegExp(rule.pattern);
+  } catch {
+    debugLog("profiles", `Profile "${profileName}": invalid pattern "${rule.pattern}" \u2014 skipping rule`);
+    return null;
+  }
+  return {
+    match(cmd) {
+      const match = cmd.match(regex);
+      if (!match) return null;
+      const metadata = {};
+      for (const [key, value] of Object.entries(rule.metadata ?? {})) {
+        metadata[key] = value.replace(/\$(\d+)/g, (_, index) => match[Number(index)] ?? "");
+      }
+      return { category: rule.category, metadata };
+    }
+  };
+}
+function loadProfileFromDisk(name) {
+  const filePath = import_path6.default.join(PROFILES_DIR, `${name}.json`);
+  if (!import_fs8.default.existsSync(filePath)) {
+    debugLog("profiles", `Profile "${name}" not found in cache \u2014 run: workscribe profile add ${name}`);
+    return null;
+  }
+  let candidate;
+  try {
+    candidate = JSON.parse(import_fs8.default.readFileSync(filePath, "utf-8"));
+  } catch {
+    debugLog("profiles", `Profile "${name}" contains invalid JSON \u2014 skipping`);
+    return null;
+  }
+  if (!isValidProfile(candidate)) {
+    debugLog("profiles", `Profile "${name}" failed schema validation \u2014 skipping`);
+    return null;
+  }
+  return candidate;
+}
+function getActiveProfileRules() {
+  const activeNames = readConfig().capture.profiles;
+  if (activeNames.length === 0) return [];
+  return activeNames.flatMap((name) => {
+    const profile = loadProfileFromDisk(name);
+    if (!profile) return [];
+    return profile.rules.flatMap((rule) => {
+      const compiled = compileRule(profile.name, rule);
+      return compiled ? [compiled] : [];
+    });
+  });
+}
+function getActiveProfileAiContexts() {
+  const activeNames = readConfig().capture.profiles;
+  if (activeNames.length === 0) return [];
+  return activeNames.flatMap((name) => {
+    const profile = loadProfileFromDisk(name);
+    return profile?.aiContext ? [profile.aiContext] : [];
+  });
+}
+function getCachedProfiles() {
+  if (!import_fs8.default.existsSync(PROFILES_DIR)) return [];
+  return import_fs8.default.readdirSync(PROFILES_DIR).filter((file) => file.endsWith(".json") && file !== "manifest.json").flatMap((file) => {
+    const profile = loadProfileFromDisk(file.replace(/\.json$/, ""));
+    return profile ? [profile] : [];
+  });
+}
+function detectProfilesForDirectory(dir) {
+  const manifest = readCachedManifest();
+  if (!manifest) return [];
+  const activeNames = new Set(readConfig().capture.profiles);
+  return manifest.filter((entry) => {
+    if (activeNames.has(entry.name)) return false;
+    const indicatorFiles = entry.detect?.files ?? [];
+    return indicatorFiles.length > 0 && indicatorFiles.every((file) => import_fs8.default.existsSync(import_path6.default.join(dir, file)));
+  });
+}
+
 // src/normalize/patterns.ts
 function makeRule(pattern, category, extract = () => ({})) {
   return {
@@ -490,114 +766,131 @@ function extractPackages(cmd, afterKeyword) {
   if (idx === -1) return [];
   return cmd.slice(idx + afterKeyword.length).trim().split(/\s+/).filter((part) => part && !part.startsWith("-"));
 }
-var RULES = [
+var BASE_RULES = [
   // ─── Git operations ───────────────────────────────────────────────────────
-  makeRule(/^git\s+commit\b/, "code_commit", (_m, cmd) => {
+  makeRule(/^git\s+commit\b/, "shipping", (_m, cmd) => {
     const msgMatch = cmd.match(/-m\s+["']?([^"']+)["']?/);
     return { message: msgMatch ? msgMatch[1].trim() : null };
   }),
-  makeRule(/^git\s+push\b/, "code_push", (_m, cmd) => {
+  makeRule(/^git\s+push\b/, "shipping", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { remote: parts[2] ?? "origin", branch: parts[3] ?? null };
   }),
-  makeRule(/^git\s+(pull|fetch)\b/, "code_pull", (_m, cmd) => {
+  makeRule(/^git\s+(pull|fetch)\b/, "versioning", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { subcommand: parts[1], remote: parts[2] ?? "origin" };
   }),
-  makeRule(/^git\s+(checkout|switch)\b/, "branch_switch", (_m, cmd) => {
+  makeRule(/^git\s+(checkout|switch)\b/, "versioning", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     const branch = parts.find((part) => !part.startsWith("-") && part !== "git" && part !== parts[1]);
     return { branch: branch ?? null };
   }),
-  makeRule(/^git\s+(merge|rebase)\b/, "code_merge", (_m, cmd) => {
+  makeRule(/^git\s+(merge|rebase)\b/, "shipping", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { subcommand: parts[1], target: parts[2] ?? null };
   }),
-  makeRule(/^git\s+stash\b/, "code_stash", (_m, cmd) => {
+  makeRule(/^git\s+stash\b/, "versioning", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { subcommand: parts[2] ?? "push" };
   }),
-  makeRule(/^git\s+/, "git_other", (_m, cmd) => {
+  makeRule(/^git\s+/, "versioning", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { subcommand: parts[1] ?? null };
   }),
-  // ─── Package managers — install ───────────────────────────────────────────
-  makeRule(/^npm\s+(install|i|add)\b/, "dependency_install", (_m, cmd) => ({
+  // ─── Releasing ────────────────────────────────────────────────────────────
+  makeRule(/^npm\s+publish\b/, "releasing", () => ({ tool: "npm" })),
+  makeRule(/^cargo\s+publish\b/, "releasing", () => ({ tool: "cargo" })),
+  makeRule(/^gem\s+push\b/, "releasing", () => ({ tool: "gem" })),
+  makeRule(/^docker\s+push\b/, "releasing", (_m, cmd) => ({ tool: "docker", image: cmd.split(/\s+/)[2] ?? null })),
+  makeRule(/^gh\s+release\b/, "releasing", (_m, cmd) => ({ tool: "gh", subcommand: cmd.split(/\s+/)[2] ?? null })),
+  makeRule(/^fly\s+(deploy|launch)\b/, "releasing", (match) => ({ tool: "fly", subcommand: match[1] })),
+  makeRule(/^vercel\s+(deploy|build|--prod)\b/, "releasing", () => ({ tool: "vercel" })),
+  makeRule(/^netlify\s+deploy\b/, "releasing", () => ({ tool: "netlify" })),
+  makeRule(/^railway\s+up\b/, "releasing", () => ({ tool: "railway" })),
+  makeRule(/^wrangler\s+deploy\b/, "releasing", () => ({ tool: "wrangler" })),
+  // ─── Dependencies ─────────────────────────────────────────────────────────
+  makeRule(/^npm\s+(install|i|add)\b/, "dependencies", (_m, cmd) => ({
     tool: "npm",
     packages: extractPackages(cmd, cmd.includes("install") ? "install" : cmd.includes(" i ") ? " i " : "add")
   })),
-  makeRule(/^(yarn|pnpm)\s+(install|add)\b/, "dependency_install", (m, cmd) => ({
+  makeRule(/^(yarn|pnpm)\s+(install|add)\b/, "dependencies", (m, cmd) => ({
     tool: m[1],
     packages: extractPackages(cmd, "add")
   })),
-  makeRule(/^bun\s+(install|add)\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^bun\s+(install|add)\b/, "dependencies", (_m, cmd) => ({
     tool: "bun",
     packages: extractPackages(cmd, "add")
   })),
-  makeRule(/^pip\s+(install)\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^pip\s+(install)\b/, "dependencies", (_m, cmd) => ({
     tool: "pip",
     packages: extractPackages(cmd, "install")
   })),
-  makeRule(/^cargo\s+add\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^cargo\s+add\b/, "dependencies", (_m, cmd) => ({
     tool: "cargo",
     packages: extractPackages(cmd, "add")
   })),
-  makeRule(/^(brew)\s+install\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^(brew)\s+install\b/, "dependencies", (_m, cmd) => ({
     tool: "brew",
     packages: extractPackages(cmd, "install")
   })),
-  makeRule(/^go\s+get\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^go\s+get\b/, "dependencies", (_m, cmd) => ({
     tool: "go",
     packages: extractPackages(cmd, "get")
   })),
-  // ─── Package managers — remove ────────────────────────────────────────────
-  makeRule(/^npm\s+(uninstall|remove|rm)\b/, "dependency_remove", (_m, cmd) => ({
+  makeRule(/^npm\s+(uninstall|remove|rm)\b/, "dependencies", (_m, cmd) => ({
     tool: "npm",
     packages: extractPackages(cmd, cmd.split(/\s+/)[1])
   })),
-  makeRule(/^(yarn|pnpm)\s+remove\b/, "dependency_remove", (m, cmd) => ({
+  makeRule(/^(yarn|pnpm)\s+remove\b/, "dependencies", (m, cmd) => ({
     tool: m[1],
     packages: extractPackages(cmd, "remove")
   })),
-  makeRule(/^bun\s+remove\b/, "dependency_remove", (_m, cmd) => ({
+  makeRule(/^bun\s+remove\b/, "dependencies", (_m, cmd) => ({
     tool: "bun",
     packages: extractPackages(cmd, "remove")
   })),
-  makeRule(/^pip\s+uninstall\b/, "dependency_remove", (_m, cmd) => ({
+  makeRule(/^pip\s+uninstall\b/, "dependencies", (_m, cmd) => ({
     tool: "pip",
     packages: extractPackages(cmd, "uninstall")
   })),
+  // Runtime version managers
+  makeRule(/^nvm\b/, "dependencies", (_m, cmd) => ({ tool: "nvm", subcommand: cmd.split(/\s+/)[1] ?? null })),
+  makeRule(/^(fnm|volta)\b/, "dependencies", (m, cmd) => ({ tool: m[1], subcommand: cmd.split(/\s+/)[1] ?? null })),
+  makeRule(/^(rbenv|pyenv|asdf)\b/, "dependencies", (m, cmd) => ({
+    tool: m[1],
+    subcommand: cmd.split(/\s+/)[1] ?? null
+  })),
   // ─── Tests ────────────────────────────────────────────────────────────────
-  makeRule(/^npm\s+(test|run\s+test)\b/, "test_run", () => ({ tool: "npm" })),
-  makeRule(/^yarn\s+test\b/, "test_run", () => ({ tool: "yarn" })),
-  makeRule(/^pnpm\s+test\b/, "test_run", () => ({ tool: "pnpm" })),
-  makeRule(/^bun\s+test\b/, "test_run", () => ({ tool: "bun" })),
-  makeRule(/^(jest|vitest)\b/, "test_run", (match) => ({ tool: match[1] })),
-  makeRule(/^pytest\b/, "test_run", () => ({ tool: "pytest" })),
-  makeRule(/^go\s+test\b/, "test_run", () => ({ tool: "go" })),
-  makeRule(/^cargo\s+test\b/, "test_run", () => ({ tool: "cargo" })),
-  makeRule(/^rspec\b/, "test_run", () => ({ tool: "rspec" })),
-  makeRule(/^(php\s+)?phpunit\b/, "test_run", () => ({ tool: "phpunit" })),
+  makeRule(/^npm\s+(test|run\s+test)\b/, "testing", () => ({ tool: "npm" })),
+  makeRule(/^yarn\s+test\b/, "testing", () => ({ tool: "yarn" })),
+  makeRule(/^pnpm\s+test\b/, "testing", () => ({ tool: "pnpm" })),
+  makeRule(/^bun\s+test\b/, "testing", () => ({ tool: "bun" })),
+  makeRule(/^(jest|vitest)\b/, "testing", (match) => ({ tool: match[1] })),
+  makeRule(/^pytest\b/, "testing", () => ({ tool: "pytest" })),
+  makeRule(/^go\s+test\b/, "testing", () => ({ tool: "go" })),
+  makeRule(/^cargo\s+test\b/, "testing", () => ({ tool: "cargo" })),
+  makeRule(/^rspec\b/, "testing", () => ({ tool: "rspec" })),
+  makeRule(/^(php\s+)?phpunit\b/, "testing", () => ({ tool: "phpunit" })),
   // ─── Build ────────────────────────────────────────────────────────────────
-  makeRule(/^npm\s+run\s+build\b/, "build", () => ({ tool: "npm" })),
-  makeRule(/^(yarn|pnpm)\s+build\b/, "build", (match) => ({ tool: match[1] })),
-  makeRule(/^bun\s+run\s+build\b/, "build", () => ({ tool: "bun" })),
-  makeRule(/^(make|gmake)\b/, "build", (match) => ({ tool: match[1] })),
-  makeRule(/^cargo\s+build\b/, "build", () => ({ tool: "cargo" })),
-  makeRule(/^go\s+build\b/, "build", () => ({ tool: "go" })),
-  makeRule(/^docker\s+build\b/, "build", () => ({ tool: "docker" })),
-  makeRule(/^(mvn|gradle)\b/, "build", (match) => ({ tool: match[1] })),
-  // ─── Dev server ───────────────────────────────────────────────────────────
-  makeRule(/^npm\s+run\s+(dev|start|serve)\b/, "server_run", (_m, cmd) => ({
+  makeRule(/^npm\s+run\s+build\b/, "building", () => ({ tool: "npm" })),
+  makeRule(/^(yarn|pnpm)\s+build\b/, "building", (match) => ({ tool: match[1] })),
+  makeRule(/^bun\s+run\s+build\b/, "building", () => ({ tool: "bun" })),
+  makeRule(/^(make|gmake)\b/, "building", (match) => ({ tool: match[1] })),
+  makeRule(/^cargo\s+build\b/, "building", () => ({ tool: "cargo" })),
+  makeRule(/^go\s+build\b/, "building", () => ({ tool: "go" })),
+  makeRule(/^docker\s+build\b/, "building", () => ({ tool: "docker" })),
+  makeRule(/^(mvn|gradle)\b/, "building", (match) => ({ tool: match[1] })),
+  // ─── Dev server / running ─────────────────────────────────────────────────
+  makeRule(/^npm\s+run\s+(dev|start|serve)\b/, "running", (_m, cmd) => ({
     tool: "npm",
     script: cmd.split(/\s+/)[2]
   })),
-  makeRule(/^(yarn|pnpm)\s+(dev|start)\b/, "server_run", (match) => ({ tool: match[1], script: match[2] })),
-  makeRule(/^bun\s+run\s+(dev|start|serve)\b/, "server_run", (_m, cmd) => ({
+  makeRule(/^(yarn|pnpm)\s+(dev|start)\b/, "running", (match) => ({ tool: match[1], script: match[2] })),
+  makeRule(/^bun\s+run\s+(dev|start|serve)\b/, "running", (_m, cmd) => ({
     tool: "bun",
     script: cmd.split(/\s+/)[2]
   })),
-  makeRule(/^python\s+.*manage\.py\s+runserver\b/, "server_run", () => ({ tool: "django" })),
+  makeRule(/^python\s+.*manage\.py\s+runserver\b/, "running", () => ({ tool: "django" })),
   // ─── Infrastructure ───────────────────────────────────────────────────────
   makeRule(/^ssh\b/, "infrastructure", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
@@ -611,7 +904,7 @@ var RULES = [
     const parts = cmd.split(/\s+/);
     return { tool: m[1], subcommand: parts[1] ?? null };
   }),
-  makeRule(/^docker\s+(run|compose|ps|stop|start|rm|exec)\b/, "infrastructure", (m, cmd) => {
+  makeRule(/^docker\s+(run|compose|ps|stop|start|rm|exec)\b/, "infrastructure", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { tool: "docker", subcommand: parts[1] };
   }),
@@ -619,62 +912,76 @@ var RULES = [
     const parts = cmd.split(/\s+/);
     return { tool: m[1], subcommand: parts[1] ?? null };
   }),
+  // ─── Database ─────────────────────────────────────────────────────────────
+  makeRule(/^(psql|pgcli)\b/, "database", (m) => ({ tool: m[1] })),
+  makeRule(/^(mysql|mycli)\b/, "database", (m) => ({ tool: m[1] })),
+  makeRule(/^sqlite3\b/, "database", () => ({ tool: "sqlite3" })),
+  makeRule(/^(mongosh|mongo)\b/, "database", (m) => ({ tool: m[1] })),
+  makeRule(/^redis-cli\b/, "database", () => ({ tool: "redis-cli" })),
   // ─── npx ─────────────────────────────────────────────────────────────────
-  makeRule(/^npx\s+(jest|vitest|mocha|ava|tap)\b/, "test_run", (_m, cmd) => ({
+  makeRule(/^npx\s+(jest|vitest|mocha|ava|tap)\b/, "testing", (_m, cmd) => ({
     tool: cmd.split(/\s+/)[1]
   })),
-  makeRule(/^npx\s+tsc\b/, "build", () => ({ tool: "tsc" })),
-  makeRule(/^npx\s+(eslint|tslint|biome)\b/, "lint_run", (_m, cmd) => ({
+  makeRule(/^npx\s+tsc\b/, "building", () => ({ tool: "tsc" })),
+  makeRule(/^npx\s+(eslint|tslint|biome)\b/, "linting", (_m, cmd) => ({
     tool: cmd.split(/\s+/)[1]
   })),
-  makeRule(/^npx\s+(prettier|dprint)\b/, "lint_run", (_m, cmd) => ({
+  makeRule(/^npx\s+(prettier|dprint)\b/, "linting", (_m, cmd) => ({
     tool: cmd.split(/\s+/)[1]
   })),
-  makeRule(/^npx\s+\S+/, "script_run", (_m, cmd) => ({
+  makeRule(/^npx\s+\S+/, "running", (_m, cmd) => ({
     tool: cmd.split(/\s+/)[1]
   })),
   // ─── Scripts ──────────────────────────────────────────────────────────────
-  makeRule(/^(bash|sh|zsh|fish)\s+\S+/, "script_run", (match) => ({ shell: match[1] })),
-  makeRule(/^node\s+\S+\.(?:js|mjs|cjs)\b/, "script_run", () => ({ runtime: "node" })),
-  makeRule(/^python3?\s+\S+\.py\b/, "script_run", () => ({ runtime: "python" })),
-  // ─── Environment ──────────────────────────────────────────────────────────
-  makeRule(/^export\s+\w+=/, "environment", (_m, cmd) => {
-    const varName = cmd.match(/^export\s+(\w+)=/)?.[1] ?? null;
-    return { variable: varName };
-  }),
-  makeRule(/^source\s+/, "environment", () => ({})),
+  makeRule(/^(bash|sh|zsh|fish)\s+\S+/, "running", (match) => ({ shell: match[1] })),
+  makeRule(/^node\s+\S+\.(?:js|mjs|cjs)\b/, "running", () => ({ runtime: "node" })),
+  makeRule(/^python3?\s+\S+\.py\b/, "running", () => ({ runtime: "python" })),
+  // ─── Linting / code quality ───────────────────────────────────────────────
+  makeRule(/^(eslint|tslint|biome)\b/, "linting", (match) => ({ tool: match[1] })),
+  makeRule(/^(prettier|dprint)\b/, "linting", (match) => ({ tool: match[1] })),
   // ─── generic run scripts ──────────────────────────────────────────────────
-  makeRule(/^npm\s+run\s+\S+/, "script_run", (_m, cmd) => ({
+  makeRule(/^npm\s+run\s+\S+/, "running", (_m, cmd) => ({
     tool: "npm",
     script: cmd.split(/\s+/)[2]
   })),
-  makeRule(/^bun\s+run\s+\S+/, "script_run", (_m, cmd) => ({
+  makeRule(/^bun\s+run\s+\S+/, "running", (_m, cmd) => ({
     tool: "bun",
     script: cmd.split(/\s+/)[2]
   })),
   // ─── Code search ─────────────────────────────────────────────────────────
-  makeRule(/^(grep|egrep|fgrep)\b/, "code_search", (match) => ({ tool: match[1] })),
-  makeRule(/^(rg|ag|ack|ripgrep)\b/, "code_search", (match) => ({ tool: match[1] })),
-  makeRule(/^find\s/, "code_search", () => ({ tool: "find" })),
+  makeRule(/^(grep|egrep|fgrep)\b/, "exploring", (match) => ({ tool: match[1] })),
+  makeRule(/^(rg|ag|ack|ripgrep)\b/, "exploring", (match) => ({ tool: match[1] })),
+  makeRule(/^find\s/, "exploring", () => ({ tool: "find" })),
   // ─── Code read ────────────────────────────────────────────────────────────
-  makeRule(/^(cat|bat|less|more)\s+\S+/, "code_read", (match) => ({ tool: match[1] })),
-  makeRule(/^(head|tail)\b/, "code_read", (match) => ({ tool: match[1] })),
+  makeRule(/^(cat|bat|less|more)\s+\S+/, "exploring", (match) => ({ tool: match[1] })),
+  makeRule(/^(head|tail)\b/, "exploring", (match) => ({ tool: match[1] })),
   // ─── File operations ──────────────────────────────────────────────────────
-  makeRule(/^(cp|rsync)\b/, "file_ops", (match) => ({ tool: match[1] })),
-  makeRule(/^(mv)\b/, "file_ops", () => ({ tool: "mv" })),
-  makeRule(/^(rm|rmdir)\b/, "file_ops", (match) => ({ tool: match[1] })),
-  makeRule(/^(mkdir|touch|ln)\b/, "file_ops", (match) => ({ tool: match[1] })),
-  makeRule(/^(chmod|chown|chgrp)\b/, "file_ops", (match) => ({ tool: match[1] })),
-  // ─── AI terminal tools (registry-driven) ─────────────────────────────────
-  ...loadAIToolRegistry().flatMap((entry) => {
+  makeRule(/^(cp|rsync)\b/, "files", (match) => ({ tool: match[1] })),
+  makeRule(/^(mv)\b/, "files", () => ({ tool: "mv" })),
+  makeRule(/^(rm|rmdir)\b/, "files", (match) => ({ tool: match[1] })),
+  makeRule(/^(mkdir|touch|ln)\b/, "files", (match) => ({ tool: match[1] })),
+  makeRule(/^(chmod|chown|chgrp)\b/, "files", (match) => ({ tool: match[1] })),
+  // ─── Environment ──────────────────────────────────────────────────────────
+  makeRule(/^export\s+\w+=/, "files", (_m, cmd) => {
+    const varName = cmd.match(/^export\s+(\w+)=/)?.[1] ?? null;
+    return { variable: varName };
+  }),
+  makeRule(/^source\s+/, "files", () => ({}))
+];
+function aiToolRules() {
+  return loadAIToolRegistry().flatMap((entry) => {
     try {
       return [makeRule(new RegExp(entry.pattern), "ai_session", () => ({ tool: entry.tool }))];
     } catch {
       debugLog("registry", `Skipping tool "${entry.tool}" \u2014 invalid pattern: ${entry.pattern}`);
       return [];
     }
-  })
-];
+  });
+}
+function buildRules(profileRules = []) {
+  return [...BASE_RULES, ...profileRules, ...aiToolRules()];
+}
+var RULES = buildRules(getActiveProfileRules());
 function normalizeCommand(command) {
   let trimmed = command.trim().replace(/\s+/g, " ");
   trimmed = trimmed.replace(/^(git)\s+-C\s+\S+\s+/, "$1 ");
@@ -685,87 +992,6 @@ function normalizeCommand(command) {
   return { category: "other", metadata: {} };
 }
 
-// src/config/index.ts
-var import_fs6 = __toESM(require("fs"));
-var DEFAULTS = {
-  ai: {
-    provider: "",
-    apiKey: "",
-    model: "",
-    baseUrl: ""
-  },
-  session: {
-    idleTimeout: 30
-  },
-  capture: {
-    ignore: ["cd", "ls", "ll", "la", "ls -la", "ls -l", "ls -a", "pwd", "clear", "exit", "history", "man"],
-    aiTools: true,
-    includeAiderPrompt: true
-  },
-  redact: {
-    extra: []
-  },
-  summary: {
-    format: "markdown"
-  }
-};
-function readConfig() {
-  if (!import_fs6.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
-  try {
-    const raw = import_fs6.default.readFileSync(CONFIG_PATH, "utf-8");
-    const parsed = JSON.parse(raw);
-    return deepMerge(DEFAULTS, parsed);
-  } catch {
-    return { ...DEFAULTS };
-  }
-}
-function writeConfig(config) {
-  import_fs6.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
-  try {
-    import_fs6.default.chmodSync(CONFIG_PATH, 384);
-  } catch {
-  }
-}
-function getConfigValue(config, key) {
-  const parts = key.split(".");
-  let cur = config;
-  for (const part of parts) {
-    if (cur == null || typeof cur !== "object") return void 0;
-    cur = cur[part];
-  }
-  return cur;
-}
-function setConfigValue(config, key, value) {
-  const parts = key.split(".");
-  const result = JSON.parse(JSON.stringify(config));
-  let cur = result;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (cur[part] == null || typeof cur[part] !== "object") {
-      cur[part] = {};
-    }
-    cur = cur[part];
-  }
-  const lastKey = parts[parts.length - 1];
-  if (value === "true") cur[lastKey] = true;
-  else if (value === "false") cur[lastKey] = false;
-  else if (!isNaN(Number(value))) cur[lastKey] = Number(value);
-  else cur[lastKey] = value;
-  return result;
-}
-function deepMerge(defaults, overrides) {
-  const result = { ...defaults };
-  for (const key of Object.keys(overrides)) {
-    const val = overrides[key];
-    if (val !== null && typeof val === "object" && !Array.isArray(val) && typeof defaults[key] === "object") {
-      result[key] = deepMerge(defaults[key], val);
-    } else if (val !== void 0) {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-
 // src/capture/filter.ts
 function normalizeForFilter(cmd) {
   return cmd.trim().replace(/\s+/g, " ");
@@ -789,7 +1015,7 @@ function isDuplicate(command, cwd, lastEvent, dedupWindowMs = 5e3, now = Date.no
 
 // src/capture/index.ts
 function captureCommand(opts) {
-  if (import_fs7.default.existsSync(PAUSE_FLAG_PATH)) return;
+  if (import_fs9.default.existsSync(PAUSE_FLAG_PATH)) return;
   const config = readConfig();
   const { command, cwd, exitCode, durationMs } = opts;
   if (shouldFilter(command, config.capture.ignore)) return;
@@ -887,21 +1113,21 @@ function registerHook(program2) {
 }
 
 // src/cli/init.ts
-var import_fs10 = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
+var import_fs12 = __toESM(require("fs"));
+var import_path9 = __toESM(require("path"));
 var import_os4 = __toESM(require("os"));
 var import_prompts = __toESM(require("prompts"));
 var import_chalk2 = __toESM(require("chalk"));
 
 // src/capture/shell-hook.ts
-var import_fs8 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
+var import_fs10 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
 var HOOK_START = "# workscribe:hook:start";
 var HOOK_END = "# workscribe:hook:end";
 var HOOK_PREAMBLE = "# Workscribe \u2014 developer work journal";
 function getInstalledHookBlock(rcFile) {
-  if (!import_fs8.default.existsSync(rcFile)) return null;
-  const content = import_fs8.default.readFileSync(rcFile, "utf-8");
+  if (!import_fs10.default.existsSync(rcFile)) return null;
+  const content = import_fs10.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -917,38 +1143,38 @@ function isHookOutdated(rcFile, hookContent) {
 }
 function installHook(rcFile, hookContent) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs8.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
-  import_fs8.default.appendFileSync(rcFile, `
+  import_fs10.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
+  import_fs10.default.appendFileSync(rcFile, `
 ${hookContent}
 `);
 }
 function updateHook(rcFile, hookContent) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs8.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
-  const content = import_fs8.default.readFileSync(rcFile, "utf-8");
+  import_fs10.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
+  const content = import_fs10.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
-  import_fs8.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
+  import_fs10.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
 }
 function removeHook(rcFile) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs8.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
-  const content = import_fs8.default.readFileSync(rcFile, "utf-8");
+  import_fs10.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
+  const content = import_fs10.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
   const preambleIdx = content.lastIndexOf(HOOK_PREAMBLE, startIdx);
   const blockStart = preambleIdx !== -1 ? preambleIdx : startIdx;
   const before = content.slice(0, blockStart).replace(/\n+$/, "\n");
   const after = content.slice(endIdx).replace(/^\n/, "");
-  import_fs8.default.writeFileSync(rcFile, before + after);
+  import_fs10.default.writeFileSync(rcFile, before + after);
 }
 
 // src/capture/hooks/claude-code.ts
-var import_fs9 = __toESM(require("fs"));
-var import_path6 = __toESM(require("path"));
+var import_fs11 = __toESM(require("fs"));
+var import_path8 = __toESM(require("path"));
 var import_os3 = __toESM(require("os"));
 
 // src/capture/hooks/utils.ts
@@ -963,11 +1189,11 @@ function isCommandInstalled(cmd) {
 }
 
 // src/capture/hooks/claude-code.ts
-var CLAUDE_SETTINGS_PATH = import_path6.default.join(import_os3.default.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = import_path8.default.join(import_os3.default.homedir(), ".claude", "settings.json");
 function readSettings() {
-  if (!import_fs9.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  if (!import_fs11.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(import_fs9.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+    return JSON.parse(import_fs11.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -1002,8 +1228,8 @@ var claudeCodeIntegration = {
         }
       ]
     };
-    import_fs9.default.mkdirSync(import_path6.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
-    import_fs9.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    import_fs11.default.mkdirSync(import_path8.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+    import_fs11.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
   }
 };
 
@@ -1015,22 +1241,25 @@ var AI_HOOK_INTEGRATIONS = {
 // src/cli/init.ts
 function detectShell() {
   const shell = process.env.SHELL ?? "";
-  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path7.default.join(import_os4.default.homedir(), ".zshrc") };
-  if (shell.includes("bash")) return { name: "bash", rcFile: import_path7.default.join(import_os4.default.homedir(), ".bashrc") };
+  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path9.default.join(import_os4.default.homedir(), ".zshrc") };
+  if (shell.includes("bash")) return { name: "bash", rcFile: import_path9.default.join(import_os4.default.homedir(), ".bashrc") };
   return null;
 }
 function registerInit(program2) {
   program2.command("init").description("Set up Workscribe and install or update shell hooks").action(async () => {
     log.plain(import_chalk2.default.bold("\n  Workscribe \u2014 Developer Work Journal\n"));
-    if (!import_fs10.default.existsSync(WORKSCRIBE_DIR)) {
-      import_fs10.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
+    if (!import_fs12.default.existsSync(WORKSCRIBE_DIR)) {
+      import_fs12.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
       log.success(`Created ${WORKSCRIBE_DIR}`);
     } else {
       try {
-        import_fs10.default.chmodSync(WORKSCRIBE_DIR, 448);
+        import_fs12.default.chmodSync(WORKSCRIBE_DIR, 448);
       } catch {
       }
     }
+    if (!import_fs12.default.existsSync(PROFILES_DIR)) {
+      import_fs12.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
+    }
     getDb();
     log.success("Database initialized");
     const shell = detectShell();
@@ -1038,12 +1267,12 @@ function registerInit(program2) {
       log.warn("Could not detect shell. Supported: zsh, bash");
       log.plain(`Manually add the hook from: ${import_chalk2.default.cyan("shell/hook.zsh")} or ${import_chalk2.default.cyan("shell/hook.bash")}`);
     } else {
-      const hookFile = import_path7.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
-      if (!import_fs10.default.existsSync(hookFile)) {
+      const hookFile = import_path9.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
+      if (!import_fs12.default.existsSync(hookFile)) {
         log.warn(`Hook template not found at ${hookFile}`);
       } else {
-        const hookContent = import_fs10.default.readFileSync(hookFile, "utf-8");
-        if (!import_fs10.default.existsSync(shell.rcFile)) import_fs10.default.writeFileSync(shell.rcFile, "");
+        const hookContent = import_fs12.default.readFileSync(hookFile, "utf-8");
+        if (!import_fs12.default.existsSync(shell.rcFile)) import_fs12.default.writeFileSync(shell.rcFile, "");
         if (!isHookInstalled(shell.rcFile)) {
           installHook(shell.rcFile, hookContent);
           log.success(`Shell hook installed in ${shell.rcFile}`);
@@ -1092,6 +1321,33 @@ function registerInit(program2) {
       }
     }
     const config = readConfig();
+    try {
+      await cacheManifest();
+      const detected = detectProfilesForDirectory(process.cwd());
+      const alreadyActive = new Set(config.capture.profiles);
+      const toPrompt = detected.filter((entry) => !alreadyActive.has(entry.name));
+      if (toPrompt.length > 0) {
+        log.plain("");
+        for (const entry of toPrompt) {
+          const { install } = await (0, import_prompts.default)({
+            type: "confirm",
+            name: "install",
+            message: `${entry.displayName} project detected. Enable the ${entry.displayName} profile?`,
+            initial: true
+          });
+          if (install) {
+            await installProfile(entry.name);
+            config.capture.profiles = [.../* @__PURE__ */ new Set([...config.capture.profiles, entry.name])];
+            log.success(`${entry.displayName} profile enabled`);
+          }
+        }
+        writeConfig(config);
+      } else if (detected.length === 0) {
+        log.info("No project profiles detected \u2014 run workscribe profile detect from your project directory");
+      }
+    } catch {
+      log.info("Could not reach profile registry \u2014 run workscribe profile detect after connecting");
+    }
     if (config.ai.provider) {
       log.info(`AI provider already configured: ${import_chalk2.default.cyan(config.ai.provider)}`);
     } else {
@@ -1139,7 +1395,7 @@ function registerInit(program2) {
         log.info("Skipped \u2014 run later: workscribe config set ai.provider <provider>");
       }
     }
-    if (!import_fs10.default.existsSync(CONFIG_PATH)) {
+    if (!import_fs12.default.existsSync(CONFIG_PATH)) {
       writeConfig(config);
       log.success("Config file created");
     }
@@ -1158,7 +1414,7 @@ function registerInit(program2) {
 }
 
 // src/cli/status.ts
-var import_fs11 = __toESM(require("fs"));
+var import_fs13 = __toESM(require("fs"));
 var import_chalk3 = __toESM(require("chalk"));
 
 // src/utils/format.ts
@@ -1216,7 +1472,7 @@ function registerStatus(program2) {
     const total = getEventCount();
     const todayEvents = getEventsForDate(todayDate());
     const last = getLastEvent();
-    const isPaused = import_fs11.default.existsSync(PAUSE_FLAG_PATH);
+    const isPaused = import_fs13.default.existsSync(PAUSE_FLAG_PATH);
     log.plain("");
     log.plain(import_chalk3.default.bold("  Workscribe Status"));
     log.plain("");
@@ -1235,6 +1491,25 @@ function registerStatus(program2) {
       `  AI provider  ${config.ai.provider ? import_chalk3.default.cyan(config.ai.provider) : import_chalk3.default.yellow("not configured")}`
     );
     if (config.ai.model) log.plain(`  Model        ${import_chalk3.default.dim(config.ai.model)}`);
+    const activeProfiles = config.capture.profiles;
+    log.plain(
+      `  Profiles     ${activeProfiles.length > 0 ? import_chalk3.default.cyan(activeProfiles.join(", ")) : import_chalk3.default.dim("none")}`
+    );
+    const { total: weekTotal, otherCount } = getRecentOtherRate(7);
+    if (weekTotal > 0) {
+      const otherPct = Math.round(otherCount / weekTotal * 100);
+      if (otherPct >= 25) {
+        log.plain("");
+        log.plain(
+          `  ${import_chalk3.default.yellow("\u26A0")}  ${otherCount} of ${weekTotal} events (${otherPct}%) are uncategorised this week.`
+        );
+        log.plain(
+          import_chalk3.default.dim(
+            "     Run workscribe profile detect  \u2014 scan current directory for matching profiles\n     Run workscribe profile suggest  \u2014 analyse your command history"
+          )
+        );
+      }
+    }
     log.plain("");
   });
 }
@@ -1242,26 +1517,19 @@ function registerStatus(program2) {
 // src/cli/events.ts
 var import_chalk4 = __toESM(require("chalk"));
 var CATEGORY_COLORS = {
-  code_commit: import_chalk4.default.green,
-  code_push: import_chalk4.default.green,
-  code_pull: import_chalk4.default.blue,
-  branch_switch: import_chalk4.default.blue,
-  dependency_install: import_chalk4.default.yellow,
-  dependency_remove: import_chalk4.default.yellow,
-  test_run: import_chalk4.default.magenta,
-  build: import_chalk4.default.cyan,
-  server_run: import_chalk4.default.cyan,
+  shipping: import_chalk4.default.green,
+  versioning: import_chalk4.default.blue,
+  building: import_chalk4.default.cyan,
+  running: import_chalk4.default.white,
+  testing: import_chalk4.default.magenta,
+  linting: import_chalk4.default.yellow,
+  dependencies: import_chalk4.default.yellow,
   infrastructure: import_chalk4.default.red,
-  script_run: import_chalk4.default.white,
-  environment: import_chalk4.default.gray,
-  git_other: import_chalk4.default.blue,
-  code_merge: import_chalk4.default.green,
-  code_stash: import_chalk4.default.blue,
+  releasing: import_chalk4.default.bold.green,
+  database: import_chalk4.default.bold.blue,
+  files: import_chalk4.default.dim.yellow,
+  exploring: import_chalk4.default.dim.cyan,
   ai_session: import_chalk4.default.bold.magenta,
-  lint_run: import_chalk4.default.yellow,
-  code_search: import_chalk4.default.dim.cyan,
-  code_read: import_chalk4.default.dim.white,
-  file_ops: import_chalk4.default.yellow,
   other: import_chalk4.default.gray
 };
 var AI_TOOL_DISPLAY_NAMES = Object.fromEntries(
@@ -1454,9 +1722,9 @@ function registerSessions(program2) {
 
 // src/cli/summary.ts
 var import_chalk6 = __toESM(require("chalk"));
-var import_fs12 = __toESM(require("fs"));
+var import_fs14 = __toESM(require("fs"));
 var import_os5 = __toESM(require("os"));
-var import_path8 = __toESM(require("path"));
+var import_path10 = __toESM(require("path"));
 
 // src/ai/prompt.ts
 var SYSTEM_PROMPT = `You write short developer work summaries. Here is an example:
@@ -1466,27 +1734,34 @@ Project: api-service
 Branch: feature/auth
 Duration: 2h 00m
 Events:
-  - branch_switch {"branch":"feature/auth"}
-  - 2x dependency_install {"tool":"npm","packages":["bcrypt","jsonwebtoken"]}
-  - 2x test_run {"tool":"jest"} [failed]
-  - test_run {"tool":"jest"}
-  - 2x file_ops {"tool":"mkdir"}
-  - code_commit {"message":"fix: auth token validation"}
-  - code_push {"remote":"origin","branch":"feature/auth"}
+  - versioning {"branch":"feature/auth"}
+  - 2x dependencies {"tool":"npm","packages":["bcrypt","jsonwebtoken"]}
+  - 2x testing {"tool":"jest"} [failed]
+  - testing {"tool":"jest"}
+  - 2x files {"tool":"mkdir"}
+  - shipping {"message":"fix: auth token validation"}
+  - shipping {"remote":"origin","branch":"feature/auth"}
 
 OUTPUT:
 - Switched to the authentication feature branch and added authentication dependencies (bcrypt, JWT)
 - Resolved failing auth tests
 - Committed and pushed authentication fixes
 
-For dependency_install events: infer the purpose of packages from their names and describe the domain, not just the packages. Examples: bcrypt/jsonwebtoken \u2192 authentication, prisma/mongoose/pg \u2192 database, jest/vitest/mocha \u2192 testing, axios/got/node-fetch \u2192 HTTP client, stripe/paypal \u2192 payments, socket.io/ws \u2192 real-time. Use your knowledge of common packages. For unfamiliar packages, name them directly without guessing their domain.
+For dependencies events with a packages field: infer the purpose of packages from their names and describe the domain, not just the packages. Examples: bcrypt/jsonwebtoken \u2192 authentication, prisma/mongoose/pg \u2192 database, jest/vitest/mocha \u2192 testing, axios/got/node-fetch \u2192 HTTP client, stripe/paypal \u2192 payments, socket.io/ws \u2192 real-time. Use your knowledge of common packages. For unfamiliar packages, name them directly without guessing their domain.
 
-Events like code_push, build, file_ops, and code_stash provide context \u2014 fold them into the surrounding narrative rather than listing them as separate bullets. Only surface them directly when they are the main activity (e.g. a standalone build fix, or a significant restructure with no accompanying commits).
+Events like shipping (pushes), building, versioning (branch switches, stash), files (file ops, env vars), and infrastructure provide context \u2014 fold them into the surrounding narrative rather than listing them as separate bullets. Only surface them directly when they are the main activity (e.g. a standalone build fix, a deploy, or a significant restructure with no accompanying commits).
 
 For ai_session events: describe what was built during the AI session using the tool name (e.g. "via Claude Code"). If a commits array is present in metadata, use those commit messages to describe what was built. Group all activity from the session into one narrative bullet.
 
+For other events with a hint field: interpret the command snippet and describe the activity in plain language. Do not quote the raw command.
+
 Maximum 5 bullets. Output ONLY the bullet points, nothing else.`;
-var EXCLUDED = /* @__PURE__ */ new Set(["environment", "code_search", "code_read", "server_run", "git_other"]);
+function getSystemPrompt() {
+  const contexts = getActiveProfileAiContexts();
+  if (contexts.length === 0) return SYSTEM_PROMPT;
+  return SYSTEM_PROMPT + "\n\n" + contexts.join("\n");
+}
+var EXCLUDED = /* @__PURE__ */ new Set(["exploring"]);
 function buildUserMessage(payload) {
   const lines = [`Date: ${payload.date}`, ""];
   for (const session of payload.sessions) {
@@ -1613,7 +1888,7 @@ var AnthropicProvider = class {
       body: JSON.stringify({
         model: this.model,
         max_tokens: 1024,
-        system: SYSTEM_PROMPT,
+        system: getSystemPrompt(),
         messages: [{ role: "user", content: buildUserMessage(payload) }]
       })
     });
@@ -1668,7 +1943,7 @@ var OpenAIProvider = class {
       body: JSON.stringify({
         model: this.model,
         messages: [
-          { role: "system", content: SYSTEM_PROMPT },
+          { role: "system", content: getSystemPrompt() },
           { role: "user", content: buildUserMessage(payload) }
         ],
         max_tokens: 1024
@@ -1722,7 +1997,7 @@ var OllamaProvider = class {
         model: this.model,
         stream: false,
         messages: [
-          { role: "system", content: SYSTEM_PROMPT },
+          { role: "system", content: getSystemPrompt() },
           { role: "user", content: buildUserMessage(payload) }
         ],
         options: {
@@ -1904,9 +2179,9 @@ function registerSummary(program2) {
         return;
       }
       const cacheKey = isoWeekKey(today);
-      const cacheFile = import_path8.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
-      if (!opts.fresh && import_fs12.default.existsSync(cacheFile)) {
-        const cached = import_fs12.default.readFileSync(cacheFile, "utf-8");
+      const cacheFile = import_path10.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
+      if (!opts.fresh && import_fs14.default.existsSync(cacheFile)) {
+        const cached = import_fs14.default.readFileSync(cacheFile, "utf-8");
         log.plain("");
         log.plain(cached);
         log.plain("");
@@ -1922,8 +2197,8 @@ function registerSummary(program2) {
         log.plain("");
         log.plain(summary);
         log.plain("");
-        import_fs12.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
-        import_fs12.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
+        import_fs14.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+        import_fs14.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
         await handleWebhook(opts, config, summary);
       } catch (e) {
         log.error(`Weekly summary failed [${config.ai.provider}]: ${e.message}`);
@@ -2010,8 +2285,8 @@ ${bullets.trim()}`;
 }
 
 // src/cli/export.ts
-var import_fs13 = __toESM(require("fs"));
-var import_path9 = __toESM(require("path"));
+var import_fs15 = __toESM(require("fs"));
+var import_path11 = __toESM(require("path"));
 function eventRowToPayload2(row) {
   let metadata = {};
   try {
@@ -2067,9 +2342,9 @@ function registerExport(program2) {
     const payload = { date, sessions: sessionPayloads };
     log.info(`Generating summary via ${config.ai.provider}\u2026`);
     const summary = await provider.summarize(payload);
-    const outputPath = opts.output ?? import_path9.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
-    if (!import_fs13.default.existsSync(EXPORTS_DIR)) import_fs13.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
-    import_fs13.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
+    const outputPath = opts.output ?? import_path11.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
+    if (!import_fs15.default.existsSync(EXPORTS_DIR)) import_fs15.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
+    import_fs15.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
 
 ${summary}
 `, { encoding: "utf-8", mode: 384 });
@@ -2141,22 +2416,22 @@ function printConfig(obj, indent) {
 }
 
 // src/cli/pause.ts
-var import_fs14 = __toESM(require("fs"));
+var import_fs16 = __toESM(require("fs"));
 function registerPause(program2) {
   program2.command("pause").description("Pause capture temporarily").action(() => {
-    if (import_fs14.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (import_fs16.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is already paused. Run workscribe resume to restart.");
       return;
     }
-    import_fs14.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
+    import_fs16.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
     log.success("Capture paused. Run workscribe resume to restart.");
   });
   program2.command("resume").description("Resume capture after a pause").action(() => {
-    if (!import_fs14.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (!import_fs16.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is not paused.");
       return;
     }
-    import_fs14.default.rmSync(PAUSE_FLAG_PATH);
+    import_fs16.default.rmSync(PAUSE_FLAG_PATH);
     log.success("Capture resumed.");
   });
 }
@@ -2241,18 +2516,18 @@ function registerClear(program2) {
 }
 
 // src/cli/uninstall.ts
-var import_fs15 = __toESM(require("fs"));
-var import_path10 = __toESM(require("path"));
+var import_fs17 = __toESM(require("fs"));
+var import_path12 = __toESM(require("path"));
 var import_os6 = __toESM(require("os"));
 var import_prompts3 = __toESM(require("prompts"));
 var import_chalk9 = __toESM(require("chalk"));
 function detectShellRcFiles() {
   const candidates = [
-    { name: "zsh", rcFile: import_path10.default.join(import_os6.default.homedir(), ".zshrc") },
-    { name: "bash", rcFile: import_path10.default.join(import_os6.default.homedir(), ".bashrc") },
-    { name: "bash", rcFile: import_path10.default.join(import_os6.default.homedir(), ".bash_profile") }
+    { name: "zsh", rcFile: import_path12.default.join(import_os6.default.homedir(), ".zshrc") },
+    { name: "bash", rcFile: import_path12.default.join(import_os6.default.homedir(), ".bashrc") },
+    { name: "bash", rcFile: import_path12.default.join(import_os6.default.homedir(), ".bash_profile") }
   ];
-  return candidates.filter((candidate) => import_fs15.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
+  return candidates.filter((candidate) => import_fs17.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
 }
 function registerUninstall(program2) {
   program2.command("uninstall").description("Remove shell hooks and optionally delete all Workscribe data").option("--hooks-only", "remove shell hooks only, skip data deletion prompt (used by npm preuninstall)").action(async (opts) => {
@@ -2271,7 +2546,7 @@ function registerUninstall(program2) {
       }
     }
     if (opts.hooksOnly) return;
-    if (import_fs15.default.existsSync(WORKSCRIBE_DIR)) {
+    if (import_fs17.default.existsSync(WORKSCRIBE_DIR)) {
       log.plain("");
       const { deleteData } = await (0, import_prompts3.default)({
         type: "confirm",
@@ -2280,7 +2555,7 @@ function registerUninstall(program2) {
         initial: false
       });
       if (deleteData) {
-        import_fs15.default.rmSync(WORKSCRIBE_DIR, { recursive: true, force: true });
+        import_fs17.default.rmSync(WORKSCRIBE_DIR, { recursive: true, force: true });
         log.success(`Deleted ${WORKSCRIBE_DIR}`);
       } else {
         log.info(`Data kept at ${WORKSCRIBE_DIR}`);
@@ -2292,9 +2567,182 @@ function registerUninstall(program2) {
   });
 }
 
+// src/cli/profile.ts
+var import_fs18 = __toESM(require("fs"));
+var import_path13 = __toESM(require("path"));
+var import_chalk10 = __toESM(require("chalk"));
+var MIN_SUGGEST_COUNT = 5;
+function registerProfile(program2) {
+  const profile = program2.command("profile").description("Manage stack profiles for better command tracking");
+  profile.command("list").description("List available profiles from the registry").action(async () => {
+    const config = readConfig();
+    const activeNames = new Set(config.capture.profiles);
+    let manifest = readCachedManifest();
+    let offline = false;
+    if (!manifest) {
+      try {
+        manifest = await cacheManifest();
+      } catch {
+        offline = true;
+        manifest = getCachedProfiles().map((p) => ({
+          name: p.name,
+          displayName: p.displayName,
+          tags: [],
+          description: "",
+          keywords: [],
+          detect: p.detect
+        }));
+      }
+    } else {
+      cacheManifest().catch(() => void 0);
+    }
+    if (offline) {
+      log.warn("Registry unreachable \u2014 showing installed profiles only");
+    }
+    if (manifest.length === 0) {
+      log.plain("No profiles available. Check your connection and try again.");
+      return;
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const entry of manifest) {
+      const tag = entry.tags[0] ?? "other";
+      if (!grouped.has(tag)) grouped.set(tag, []);
+      grouped.get(tag).push(entry);
+    }
+    log.plain("");
+    for (const [tag, entries] of grouped) {
+      log.plain(import_chalk10.default.bold(`  ${tag.charAt(0).toUpperCase() + tag.slice(1)} profiles`));
+      log.plain(import_chalk10.default.dim("  " + "\u2500".repeat(60)));
+      for (const entry of entries) {
+        const badge = activeNames.has(entry.name) ? import_chalk10.default.green(" [active]") : "";
+        const installed = import_fs18.default.existsSync(import_path13.default.join(PROFILES_DIR, `${entry.name}.json`)) ? import_chalk10.default.dim(" installed") : "";
+        log.plain(`  ${import_chalk10.default.cyan(entry.name.padEnd(18))} ${entry.displayName.padEnd(28)}${badge}${installed}`);
+        if (entry.description) log.plain(`  ${import_chalk10.default.dim(" ".repeat(18) + entry.description)}`);
+      }
+      log.plain("");
+    }
+  });
+  profile.command("add <names...>").description("Install one or more profiles from the registry").action(async (names) => {
+    const config = readConfig();
+    const activeNames = new Set(config.capture.profiles);
+    for (const name of names) {
+      if (activeNames.has(name)) {
+        log.info(`Profile "${name}" is already active`);
+        continue;
+      }
+      try {
+        log.plain(`Fetching ${import_chalk10.default.cyan(name)}\u2026`);
+        await installProfile(name);
+        activeNames.add(name);
+        log.success(`Profile "${name}" installed`);
+      } catch (err) {
+        log.error(`Failed to install "${name}": ${err.message}`);
+      }
+    }
+    config.capture.profiles = [...activeNames];
+    writeConfig(config);
+  });
+  profile.command("remove <names...>").description("Uninstall one or more profiles").action((names) => {
+    const config = readConfig();
+    const activeNames = new Set(config.capture.profiles);
+    for (const name of names) {
+      if (!activeNames.has(name)) {
+        log.warn(`Profile "${name}" is not active`);
+        continue;
+      }
+      activeNames.delete(name);
+      const cachePath = import_path13.default.join(PROFILES_DIR, `${name}.json`);
+      if (import_fs18.default.existsSync(cachePath)) import_fs18.default.unlinkSync(cachePath);
+      log.success(`Profile "${name}" removed`);
+    }
+    config.capture.profiles = [...activeNames];
+    writeConfig(config);
+  });
+  profile.command("update [name]").description("Re-fetch installed profiles from the registry").action(async (name) => {
+    const config = readConfig();
+    const toUpdate = name ? [name] : config.capture.profiles;
+    if (toUpdate.length === 0) {
+      log.plain("No profiles installed. Run workscribe profile add <name> first.");
+      return;
+    }
+    for (const profileName of toUpdate) {
+      try {
+        log.plain(`Updating ${import_chalk10.default.cyan(profileName)}\u2026`);
+        await installProfile(profileName);
+        log.success(`${profileName} updated`);
+      } catch (err) {
+        log.error(`Failed to update "${profileName}": ${err.message}`);
+      }
+    }
+  });
+  profile.command("detect").description("Scan the current directory and suggest matching profiles").action(() => {
+    const cwd = process.cwd();
+    const matches = detectProfilesForDirectory(cwd);
+    if (matches.length === 0) {
+      const cached = readCachedManifest();
+      if (!cached) {
+        log.plain("No manifest cached. Run workscribe profile list to fetch it first.");
+      } else {
+        log.plain(`No profiles detected for ${import_chalk10.default.dim(cwd)}`);
+        log.plain(import_chalk10.default.dim("Run workscribe profile list to browse available profiles."));
+      }
+      return;
+    }
+    log.plain("");
+    log.plain(import_chalk10.default.bold("  Profiles detected for this directory:"));
+    log.plain("");
+    for (const entry of matches) {
+      const files = entry.detect?.files?.join(", ") ?? "";
+      log.plain(`  ${import_chalk10.default.cyan(entry.name.padEnd(18))} ${entry.displayName}  ${import_chalk10.default.dim("(" + files + ")")}`);
+    }
+    log.plain("");
+    log.plain(`  Run: ${import_chalk10.default.cyan("workscribe profile add " + matches.map((e) => e.name).join(" "))}`);
+    log.plain("");
+  });
+  profile.command("suggest").description("Analyse recent unclassified commands and suggest profiles").option("--days <n>", "number of days to analyse", "30").action((opts) => {
+    const days = Math.max(1, parseInt(opts.days, 10) || 30);
+    const toolCounts = getOtherEventToolCounts(days);
+    if (toolCounts.length === 0) {
+      log.plain("No unclassified commands found in the last " + days + " days.");
+      return;
+    }
+    const manifest = readCachedManifest();
+    if (!manifest) {
+      log.plain("No manifest cached. Run workscribe profile list first.");
+      return;
+    }
+    const config = readConfig();
+    const activeNames = new Set(config.capture.profiles);
+    const suggestions = [];
+    for (const entry of manifest) {
+      if (activeNames.has(entry.name)) continue;
+      const matchedCount = toolCounts.filter((tc) => entry.keywords.some((kw) => tc.tool.toLowerCase().includes(kw.toLowerCase()))).reduce((sum, tc) => sum + tc.count, 0);
+      if (matchedCount >= MIN_SUGGEST_COUNT) {
+        suggestions.push({ entry, count: matchedCount });
+      }
+    }
+    suggestions.sort((a, b) => b.count - a.count);
+    if (suggestions.length === 0) {
+      log.plain("No profile matches found. Your commands are well covered.");
+      return;
+    }
+    log.plain("");
+    log.plain(import_chalk10.default.bold(`  Analysed last ${days} days of unclassified commands:`));
+    log.plain("");
+    for (const { entry, count } of suggestions) {
+      log.plain(
+        `  ${import_chalk10.default.cyan(entry.name.padEnd(18))} ${String(count).padStart(4)} commands  \u2192  ${entry.displayName}`
+      );
+    }
+    log.plain("");
+    log.plain(`  Run: ${import_chalk10.default.cyan("workscribe profile add " + suggestions.map((s) => s.entry.name).join(" "))}`);
+    log.plain("");
+  });
+}
+
 // src/index.ts
 var program = new import_commander.Command();
-program.name("workscribe").description("Automatic developer work journal").version("1.9.0");
+program.name("workscribe").description("Automatic developer work journal").version("1.10.0");
 registerCapture(program);
 registerHook(program);
 registerInit(program);
@@ -2308,5 +2756,6 @@ registerPause(program);
 registerUndo(program);
 registerClear(program);
 registerUninstall(program);
+registerProfile(program);
 program.parse();
 //# sourceMappingURL=index.js.map