@whenlabs/when 0.9.2 → 0.10.0

package/dist/mcp.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
+import {
+  findBin
+} from "./chunk-JOMP6AU5.js";
 
-// src/mcp.ts
+// src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { spawn } from "child_process";
-import { resolve, dirname, join } from "path";
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
 import {
   initDb,
   TaskQueries,
@@ -18,15 +18,15 @@ import {
   registerStats,
   registerHistory
 } from "@whenlabs/velocity-mcp/lib";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function findBin(name) {
-  const pkgRoot = resolve(__dirname, "..");
-  const localBin = resolve(pkgRoot, "node_modules", ".bin", name);
-  if (existsSync(localBin)) return localBin;
-  const directCli = resolve(pkgRoot, "node_modules", "@whenlabs", name, "dist", "cli.js");
-  if (existsSync(directCli)) return directCli;
-  return name;
-}
+
+// src/mcp/stale.ts
+import { z } from "zod";
+
+// src/mcp/run-cli.ts
+import { spawn } from "child_process";
+import { join } from "path";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
+import { homedir } from "os";
 function runCli(bin, args, cwd) {
   return new Promise((res) => {
     const child = spawn(findBin(bin), args, {
@@ -64,6 +64,12 @@ function readAwareProjectName(path) {
     return null;
   }
 }
+function formatOutput(result) {
+  const parts = [];
+  if (result.stdout.trim()) parts.push(result.stdout.trim());
+  if (result.stderr.trim()) parts.push(result.stderr.trim());
+  return parts.join("\n") || "No output";
+}
 async function checkTriggers(toolName, result, path) {
   const output = result.stdout || result.stderr || "";
   const extras = [];
@@ -94,13 +100,743 @@ ${staleOutput}`);
         extras.push(`
 Note: Conflicts found in project "${projectName}".`);
       }
+      try {
+        const cacheFiles = readdirSync(CACHE_DIR).filter((f) => f.startsWith("stale_"));
+        for (const cacheFile of cacheFiles) {
+          const cached = JSON.parse(readFileSync(join(CACHE_DIR, cacheFile), "utf8"));
+          if (/\b\d{4,5}\b/.test(cached.output || "")) {
+            extras.push("\nTip: Port references found in documentation \u2014 stale_scan may need re-run after resolving conflicts.");
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (toolName === "envalid_detect") {
+    const serviceUrlMatches = output.match(/\b[A-Z_]*(?:HOST|PORT|URL|URI)[A-Z_]*\b/g);
+    if (serviceUrlMatches && serviceUrlMatches.length > 0) {
+      const examples = [...new Set(serviceUrlMatches)].slice(0, 3).join(", ");
+      extras.push(`
+Tip: Service URLs detected (${examples}, etc.) \u2014 run berth_register to track their ports for conflict detection.`);
+    }
+  }
+  if (toolName === "velocity_end_task") {
+    const largeChange = /actual_files["\s:]+([1-9]\d)/i.test(output) || /\b([6-9]|\d{2,})\s+files?\b/i.test(output);
+    if (largeChange) {
+      extras.push("\nTip: Large change detected \u2014 consider running stale_scan to check for documentation drift.");
+    }
+  }
+  if (toolName === "vow_scan") {
+    const cacheFile = join(CACHE_DIR, `vow_scan_${deriveProject(path)}.json`);
+    const isFirstScan = !existsSync(cacheFile);
+    const hasNewPackages = /new package|added|installed/i.test(output);
+    if (isFirstScan || hasNewPackages) {
+      extras.push("\nTip: Dependency changes detected \u2014 run aware_sync to update AI context files with new library info.");
     }
   }
   return extras;
 }
+
+// src/mcp/stale.ts
+function registerStaleTools(server2) {
+  server2.tool(
+    "stale_scan",
+    "Scan for documentation drift \u2014 detect when docs say one thing and code says another",
+    {
+      path: z.string().optional().describe("Project directory to scan (defaults to cwd)"),
+      deep: z.coerce.boolean().optional().describe("Enable AI-powered deep analysis"),
+      git: z.coerce.boolean().optional().describe("Enable git history staleness checks"),
+      format: z.enum(["terminal", "json", "markdown", "sarif"]).optional().describe("Output format")
+    },
+    async ({ path, deep, git, format }) => {
+      const args = ["scan"];
+      if (deep) args.push("--deep");
+      if (git) args.push("--git");
+      if (format) args.push("--format", format);
+      const result = await runCli("stale", args, path);
+      const output = formatOutput(result);
+      writeCache("stale", deriveProject(path), output, result.code);
+      const extras = await checkTriggers("stale_scan", result, path);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "stale_fix",
+    "Auto-fix documentation drift \u2014 generate fixes for wrong file paths, dead links, phantom env vars, outdated scripts",
+    {
+      path: z.string().optional().describe("Project directory to scan (defaults to cwd)"),
+      format: z.enum(["terminal", "diff"]).optional().describe("Output format (default: terminal)"),
+      apply: z.coerce.boolean().optional().describe("Apply high-confidence fixes directly"),
+      dryRun: z.coerce.boolean().optional().describe("Show what --apply would do without writing")
+    },
+    async ({ path, format, apply, dryRun }) => {
+      const args = ["fix"];
+      if (format) args.push("--format", format);
+      if (apply) args.push("--apply");
+      if (dryRun) args.push("--dry-run");
+      const result = await runCli("stale", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "stale_init",
+    "Generate a .stale.yml config file for customizing documentation drift detection",
+    { path: z.string().optional().describe("Project directory (defaults to cwd)") },
+    async ({ path }) => {
+      const result = await runCli("stale", ["init"], path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "stale_auto_fix",
+    "Scan for documentation drift and auto-fix high-confidence issues in one step",
+    {
+      path: z.string().optional().describe("Project directory to scan (defaults to cwd)"),
+      deep: z.coerce.boolean().optional().describe("Enable AI-powered deep analysis")
+    },
+    async ({ path, deep }) => {
+      const scanArgs = ["scan"];
+      if (deep) scanArgs.push("--deep");
+      const scanResult = await runCli("stale", scanArgs, path);
+      const scanOutput = formatOutput(scanResult);
+      writeCache("stale_scan", deriveProject(path), scanOutput, scanResult.code);
+      writeCache("stale_auto_fix", deriveProject(path), scanOutput, scanResult.code);
+      if (scanResult.code !== 0) {
+        const fixResult = await runCli("stale", ["fix", "--apply"], path);
+        const fixOutput = formatOutput(fixResult);
+        const combined = `${scanOutput}
+--- Auto-fix applied ---
+${fixOutput}`;
+        writeCache("stale_auto_fix", deriveProject(path), combined, fixResult.code);
+        return { content: [{ type: "text", text: combined }] };
+      }
+      return { content: [{ type: "text", text: scanOutput }] };
+    }
+  );
+}
+
+// src/mcp/envalid.ts
+import { z as z2 } from "zod";
+function registerEnvalidTools(server2) {
+  server2.tool(
+    "envalid_validate",
+    "Validate .env files against their schema \u2014 catch missing or invalid environment variables",
+    {
+      path: z2.string().optional().describe("Project directory (defaults to cwd)"),
+      environment: z2.string().optional().describe("Target environment (e.g. production, staging)"),
+      format: z2.enum(["terminal", "json", "markdown"]).optional().describe("Output format")
+    },
+    async ({ path, environment, format }) => {
+      const args = ["validate"];
+      if (environment) args.push("--environment", environment);
+      if (format) args.push("--format", format);
+      const result = await runCli("envalid", args, path);
+      const output = formatOutput(result);
+      writeCache("envalid_validate", deriveProject(path), output, result.code);
+      const extras = await checkTriggers("envalid_validate", result, path);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "envalid_detect",
+    "Scan codebase for env var usage and compare with schema \u2014 find undocumented env vars",
+    {
+      path: z2.string().optional().describe("Project directory (defaults to cwd)"),
+      format: z2.enum(["terminal", "json"]).optional().describe("Output format")
+    },
+    async ({ path, format }) => {
+      const args = ["detect"];
+      if (format) args.push("--format", format);
+      const result = await runCli("envalid", args, path);
+      const output = formatOutput(result);
+      writeCache("envalid_detect", deriveProject(path), output, result.code);
+      const extras = await checkTriggers("envalid_detect", result, path);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "envalid_init",
+    "Generate .env.schema from an existing .env file \u2014 bootstrap type-safe env validation",
+    {
+      path: z2.string().optional().describe("Project directory (defaults to cwd)"),
+      force: z2.coerce.boolean().optional().describe("Overwrite existing schema")
+    },
+    async ({ path, force }) => {
+      const args = ["init"];
+      if (force) args.push("--force");
+      const result = await runCli("envalid", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "envalid_diff",
+    "Compare two .env files \u2014 show added, removed, and changed variables",
+    {
+      source: z2.string().describe("Path to source .env file"),
+      target: z2.string().describe("Path to target .env file"),
+      schema: z2.string().optional().describe("Path to .env.schema for sensitivity info"),
+      format: z2.enum(["terminal", "json", "markdown"]).optional().describe("Output format")
+    },
+    async ({ source, target, schema, format }) => {
+      const args = ["diff", source, target];
+      if (schema) args.push("--schema", schema);
+      if (format) args.push("--format", format);
+      const result = await runCli("envalid", args);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "envalid_sync",
+    "Check multiple environment files against schema \u2014 ensure all envs are in sync",
+    {
+      environments: z2.string().describe('Comma-separated env file paths (e.g. ".env,.env.staging,.env.production")'),
+      path: z2.string().optional().describe("Project directory (defaults to cwd)"),
+      format: z2.enum(["terminal", "json", "markdown"]).optional().describe("Output format")
+    },
+    async ({ environments, path, format }) => {
+      const args = ["sync", "--environments", environments];
+      if (format) args.push("--format", format);
+      const result = await runCli("envalid", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "envalid_generate",
+    "Generate .env.example from schema \u2014 create a safe template without secrets",
+    {
+      path: z2.string().optional().describe("Project directory (defaults to cwd)"),
+      output: z2.string().optional().describe("Output file path (default: .env.example)")
+    },
+    async ({ path, output }) => {
+      const args = ["generate-example"];
+      if (output) args.push("--output", output);
+      const result = await runCli("envalid", args, path);
+      const outputText = formatOutput(result);
+      return { content: [{ type: "text", text: outputText }] };
+    }
+  );
+  server2.tool(
+    "envalid_secrets",
+    "Scan committed files for leaked secrets \u2014 detect API keys, tokens, passwords in code",
+    {
+      path: z2.string().optional().describe("Project directory (defaults to cwd)"),
+      format: z2.enum(["terminal", "json"]).optional().describe("Output format")
+    },
+    async ({ path, format }) => {
+      const args = ["secrets"];
+      if (format) args.push("--format", format);
+      const result = await runCli("envalid", args, path);
+      const output = formatOutput(result);
+      writeCache("envalid_secrets", deriveProject(path), output, result.code);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "envalid_generate_schema",
+    "Generate .env.schema from code analysis \u2014 infer types, required-ness, and sensitivity from usage patterns",
+    {
+      path: z2.string().optional().describe("Project directory (defaults to cwd)"),
+      output: z2.string().optional().describe("Output file path (default: .env.schema)")
+    },
+    async ({ path, output }) => {
+      const args = ["detect", "--generate"];
+      if (output) args.push("-o", output);
+      const result = await runCli("envalid", args, path);
+      const outputText = formatOutput(result);
+      return { content: [{ type: "text", text: outputText }] };
+    }
+  );
+  server2.tool(
+    "envalid_hook_status",
+    "Check if the envalid pre-commit git hook is installed",
+    { path: z2.string().optional().describe("Project directory (defaults to cwd)") },
+    async ({ path }) => {
+      const result = await runCli("envalid", ["hook", "status"], path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "envalid_auto_fix",
+    "Detect undocumented env vars and auto-generate schema entries",
+    {
+      path: z2.string().optional().describe("Project directory (defaults to cwd)")
+    },
+    async ({ path }) => {
+      const detectResult = await runCli("envalid", ["detect"], path);
+      const detectOutput = formatOutput(detectResult);
+      writeCache("envalid_detect", deriveProject(path), detectOutput, detectResult.code);
+      const hasUndocumented = /undocumented|missing from schema/i.test(detectOutput);
+      if (hasUndocumented) {
+        const generateResult = await runCli("envalid", ["detect", "--generate"], path);
+        const generateOutput = formatOutput(generateResult);
+        const combined = `${detectOutput}
+--- Auto-generated schema entries ---
+${generateOutput}`;
+        return { content: [{ type: "text", text: combined }] };
+      }
+      return { content: [{ type: "text", text: detectOutput }] };
+    }
+  );
+}
+
+// src/mcp/berth.ts
+import { z as z3 } from "zod";
+function registerBerthTools(server2) {
+  server2.tool(
+    "berth_status",
+    "Show all active ports, Docker ports, and configured ports \u2014 diagnose port conflicts",
+    {},
+    async () => {
+      const result = await runCli("berth", ["status", "--json"]);
+      const output = formatOutput(result);
+      writeCache("berth_status", deriveProject(), output, result.code);
+      const extras = await checkTriggers("berth_status", result);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "berth_check",
+    "Scan a project directory for port conflicts before starting dev servers",
+    { path: z3.string().optional().describe("Project directory to check (defaults to cwd)") },
+    async ({ path }) => {
+      const result = await runCli("berth", ["check", path || "."]);
+      const output = formatOutput(result);
+      writeCache("berth_check", deriveProject(path), output, result.code);
+      const extras = await checkTriggers("berth_check", result, path);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "berth_kill",
+    "Kill processes on a specific port \u2014 free up a port for your dev server",
+    {
+      port: z3.coerce.number().optional().describe("Port number to free"),
+      dev: z3.coerce.boolean().optional().describe("Kill all dev processes (node, python, ruby, etc.)")
+    },
+    async ({ port, dev }) => {
+      const args = ["kill"];
+      if (port) args.push(String(port));
+      if (dev) args.push("--dev");
+      args.push("--force");
+      const result = await runCli("berth", args);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "berth_free",
+    "Free all ports for a registered project \u2014 kill every process blocking the project",
+    { project: z3.string().describe("Registered project name") },
+    async ({ project }) => {
+      const result = await runCli("berth", ["free", project]);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "berth_register",
+    "Register a project directory's port requirements for conflict tracking",
+    {
+      path: z3.string().optional().describe("Project directory to register (defaults to cwd)")
+    },
+    async ({ path }) => {
+      const args = ["register", "--yes"];
+      if (path) args.push("--dir", path);
+      const result = await runCli("berth", args);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "berth_list",
+    "List all registered projects and their port statuses",
+    {},
+    async () => {
+      const result = await runCli("berth", ["list", "--json"]);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "berth_reassign",
+    "Change a port assignment in project config files (docker-compose, .env, etc.)",
+    {
+      oldPort: z3.number().describe("Current port number"),
+      newPort: z3.number().describe("New port number"),
+      project: z3.string().optional().describe("Project name from registry")
+    },
+    async ({ oldPort, newPort, project }) => {
+      const args = ["reassign", String(oldPort), String(newPort)];
+      if (project) args.push("--project", project);
+      const result = await runCli("berth", args);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "berth_start",
+    "Auto-resolve all port conflicts and prepare a project to start cleanly",
+    {
+      project: z3.string().describe("Registered project name"),
+      dryRun: z3.coerce.boolean().optional().describe("Show what would be done without making changes")
+    },
+    async ({ project, dryRun }) => {
+      const args = ["start", project];
+      if (dryRun) args.push("--dry-run");
+      const result = await runCli("berth", args);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "berth_resolve",
+    "Auto-resolve port conflicts \u2014 detect conflicts and fix via kill or reassign strategy",
+    {
+      path: z3.string().optional().describe("Project directory (defaults to cwd)"),
+      strategy: z3.enum(["kill", "reassign", "auto"]).optional().describe("Resolution strategy (default: auto)"),
+      kill: z3.coerce.boolean().optional().describe("Allow killing processes (required for kill/auto strategies)"),
+      dryRun: z3.coerce.boolean().optional().describe("Show what would be done without making changes")
+    },
+    async ({ path, strategy, kill, dryRun }) => {
+      const args = ["resolve"];
+      if (strategy) args.push("--strategy", strategy);
+      if (kill) args.push("--kill");
+      if (dryRun) args.push("--dry-run");
+      const result = await runCli("berth", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "berth_predict",
+    "Predict port conflicts from project config files before starting \u2014 dry-run conflict check",
+    { path: z3.string().optional().describe("Project directory (defaults to cwd)") },
+    async ({ path }) => {
+      const result = await runCli("berth", ["predict", path || "."]);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "berth_auto_resolve",
+    "Check for port conflicts and auto-resolve them",
+    {
+      path: z3.string().optional().describe("Project directory (defaults to cwd)"),
+      strategy: z3.enum(["kill", "reassign", "auto"]).optional().describe("Resolution strategy (default: auto)")
+    },
+    async ({ path, strategy }) => {
+      const checkResult = await runCli("berth", ["check", path || "."]);
+      const checkOutput = formatOutput(checkResult);
+      writeCache("berth_check", deriveProject(path), checkOutput, checkResult.code);
+      const hasConflicts = /conflict/i.test(checkOutput);
+      if (hasConflicts) {
+        const resolveArgs = ["resolve", "--strategy", strategy || "auto", "--kill"];
+        const resolveResult = await runCli("berth", resolveArgs, path);
+        const resolveOutput = formatOutput(resolveResult);
+        const combined = `${checkOutput}
+--- Auto-resolve applied ---
+${resolveOutput}`;
+        return { content: [{ type: "text", text: combined }] };
+      }
+      return { content: [{ type: "text", text: checkOutput }] };
+    }
+  );
+}
+
+// src/mcp/aware.ts
+import { z as z4 } from "zod";
+function registerAwareTools(server2) {
+  server2.tool(
+    "aware_init",
+    "Auto-detect project stack and generate AI context files (CLAUDE.md, .cursorrules, etc.)",
+    {
+      path: z4.string().optional().describe("Project directory (defaults to cwd)"),
+      targets: z4.string().optional().describe("Comma-separated targets: claude,cursor,copilot,agents,all"),
+      force: z4.coerce.boolean().optional().describe("Overwrite existing files without prompting")
+    },
+    async ({ path, targets, force }) => {
+      const args = ["init"];
+      if (targets) args.push("--targets", targets);
+      if (force) args.push("--force");
+      const result = await runCli("aware", args, path);
+      const output = formatOutput(result);
+      writeCache("aware_init", deriveProject(path), output, result.code);
+      const extras = await checkTriggers("aware_init", result, path);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "aware_sync",
+    "Regenerate AI context files from .aware.json \u2014 update CLAUDE.md, .cursorrules, etc.",
+    {
+      path: z4.string().optional().describe("Project directory (defaults to cwd)"),
+      dryRun: z4.coerce.boolean().optional().describe("Show what would change without writing files")
+    },
+    async ({ path, dryRun }) => {
+      const args = ["sync"];
+      if (dryRun) args.push("--dry-run");
+      const result = await runCli("aware", args, path);
+      const output = formatOutput(result);
+      writeCache("aware_sync", deriveProject(path), output, result.code);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "aware_diff",
+    "Show project changes since last sync \u2014 see what drifted in your codebase",
+    {
+      path: z4.string().optional().describe("Project directory (defaults to cwd)"),
+      exitCode: z4.coerce.boolean().optional().describe("Return exit code 1 if changes detected (useful for CI)")
+    },
+    async ({ path, exitCode }) => {
+      const args = ["diff"];
+      if (exitCode) args.push("--exit-code");
+      const result = await runCli("aware", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "aware_validate",
+    "Validate .aware.json schema and content \u2014 check for config errors",
+    { path: z4.string().optional().describe("Project directory (defaults to cwd)") },
+    async ({ path }) => {
+      const result = await runCli("aware", ["validate"], path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "aware_doctor",
+    "Diagnose project health \u2014 check config issues, stack drift, stale AI context files",
+    { path: z4.string().optional().describe("Project directory (defaults to cwd)") },
+    async ({ path }) => {
+      const result = await runCli("aware", ["doctor"], path);
+      const output = formatOutput(result);
+      writeCache("aware_doctor", deriveProject(path), output, result.code);
+      const extras = await checkTriggers("aware_doctor", result, path);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "aware_add",
+    "Add a rule, convention, or structure entry to .aware.json",
+    {
+      path: z4.string().optional().describe("Project directory (defaults to cwd)"),
+      type: z4.enum(["rule", "convention", "structure"]).describe("Type to add")
+    },
+    async ({ path, type }) => {
+      const args = ["add", "--type", type];
+      const result = await runCli("aware", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "aware_auto_sync",
+    "Diagnose project health and auto-sync stale AI context files",
+    {
+      path: z4.string().optional().describe("Project directory (defaults to cwd)")
+    },
+    async ({ path }) => {
+      const doctorResult = await runCli("aware", ["doctor"], path);
+      const doctorOutput = formatOutput(doctorResult);
+      writeCache("aware_doctor", deriveProject(path), doctorOutput, doctorResult.code);
+      const needsSync = /stale|outdated|drift/i.test(doctorOutput);
+      if (needsSync) {
+        const syncResult = await runCli("aware", ["sync"], path);
+        const syncOutput = formatOutput(syncResult);
+        const combined = `${doctorOutput}
+--- Auto-sync applied ---
+${syncOutput}`;
+        return { content: [{ type: "text", text: combined }] };
+      }
+      return { content: [{ type: "text", text: doctorOutput }] };
+    }
+  );
+}
+
+// src/mcp/vow.ts
+import { z as z5 } from "zod";
+function registerVowTools(server2) {
+  server2.tool(
+    "vow_scan",
+    "Scan dependency licenses \u2014 summarize all licenses in the project",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)"),
+      production: z5.coerce.boolean().optional().describe("Skip devDependencies"),
+      format: z5.enum(["terminal", "json"]).optional().describe("Output format")
+    },
+    async ({ path, production, format }) => {
+      const args = ["scan"];
+      if (production) args.push("--production");
+      if (format) args.push("--format", format);
+      const result = await runCli("vow", args, path);
+      const output = formatOutput(result);
+      writeCache("vow_scan", deriveProject(path), output, result.code);
+      const extras = await checkTriggers("vow_scan", result, path);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "vow_check",
+    "Validate dependency licenses against policy \u2014 flag violations before release",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)"),
+      production: z5.coerce.boolean().optional().describe("Skip devDependencies")
+    },
+    async ({ path, production }) => {
+      const args = ["check"];
+      if (production) args.push("--production");
+      const result = await runCli("vow", args, path);
+      const output = formatOutput(result);
+      writeCache("vow_check", deriveProject(path), output, result.code);
+      const extras = await checkTriggers("vow_check", result, path);
+      return { content: [{ type: "text", text: output + extras.join("") }] };
+    }
+  );
+  server2.tool(
+    "vow_init",
+    "Generate a license policy file (.vow.json) \u2014 choose from commercial, opensource, or strict templates",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)"),
+      template: z5.enum(["commercial", "opensource", "strict"]).optional().describe("Policy template")
+    },
+    async ({ path, template }) => {
+      const args = ["init"];
+      if (template) args.push("--template", template);
+      const result = await runCli("vow", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "vow_tree",
+    "Display dependency tree with license annotations \u2014 trace license inheritance",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)"),
+      filter: z5.string().optional().describe('Show only subtrees containing this license (e.g. "GPL")'),
+      depth: z5.coerce.number().optional().describe("Max tree depth"),
+      production: z5.coerce.boolean().optional().describe("Skip devDependencies")
+    },
+    async ({ path, filter, depth, production }) => {
+      const args = ["tree"];
+      if (path) args.push("--path", path);
+      if (filter) args.push("--filter", filter);
+      if (depth) args.push("--depth", String(depth));
+      if (production) args.push("--production");
+      const result = await runCli("vow", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "vow_fix",
+    "Suggest alternative packages for license policy violations \u2014 find compliant replacements",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)"),
+      production: z5.coerce.boolean().optional().describe("Skip devDependencies"),
+      limit: z5.coerce.number().optional().describe("Max alternatives per package")
+    },
+    async ({ path, production, limit }) => {
+      const args = ["fix"];
+      if (path) args.push("--path", path);
+      if (production) args.push("--production");
+      if (limit) args.push("--limit", String(limit));
+      const result = await runCli("vow", args, path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "vow_export",
+    "Export full license report as JSON, CSV, or Markdown",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)"),
+      format: z5.enum(["json", "csv", "markdown"]).optional().describe("Export format (default: json)"),
+      output: z5.string().optional().describe("Output file path"),
+      production: z5.coerce.boolean().optional().describe("Skip devDependencies")
+    },
+    async ({ path, format, output, production }) => {
+      const args = ["export"];
+      if (path) args.push("--path", path);
+      if (format) args.push("--format", format);
+      if (output) args.push("--output", output);
+      if (production) args.push("--production");
+      const result = await runCli("vow", args, path);
+      const outputText = formatOutput(result);
+      return { content: [{ type: "text", text: outputText }] };
+    }
+  );
+  server2.tool(
+    "vow_hook_install",
+    "Install a pre-commit git hook that checks dependency licenses before each commit",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)")
+    },
+    async ({ path }) => {
+      const result = await runCli("vow", ["hook", "install"], path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "vow_hook_uninstall",
+    "Remove the vow pre-commit license check hook",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)")
+    },
+    async ({ path }) => {
+      const result = await runCli("vow", ["hook", "uninstall"], path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "vow_hook_status",
+    "Check if the vow pre-commit license check hook is installed",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)")
+    },
+    async ({ path }) => {
+      const result = await runCli("vow", ["hook", "status"], path);
+      const output = formatOutput(result);
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
+  server2.tool(
+    "vow_attribution",
+    "Generate THIRD_PARTY_LICENSES.md \u2014 list all dependencies with their licenses for compliance",
+    {
+      path: z5.string().optional().describe("Project directory (defaults to cwd)"),
+      output: z5.string().optional().describe("Output file (default: THIRD_PARTY_LICENSES.md)"),
+      production: z5.coerce.boolean().optional().describe("Skip devDependencies")
+    },
+    async ({ path, output, production }) => {
+      const args = ["attribution"];
+      if (path) args.push("--path", path);
+      if (output) args.push("--output", output);
+      if (production) args.push("--production");
+      const result = await runCli("vow", args, path);
+      const outputText = formatOutput(result);
+      return { content: [{ type: "text", text: outputText }] };
+    }
+  );
+}
+
+// src/mcp/index.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var { version } = JSON.parse(readFileSync2(resolve(__dirname, "..", "package.json"), "utf8"));
 var server = new McpServer({
   name: "whenlabs",
-  version: "0.3.0"
+  version
 });
 var velocityDb = initDb();
 var velocityQueries = new TaskQueries(velocityDb);
@@ -110,587 +846,11 @@ registerEndTask(s, velocityQueries);
 registerEstimate(s, velocityQueries);
 registerStats(s, velocityQueries);
 registerHistory(s, velocityQueries);
-function formatOutput(result) {
-  const parts = [];
-  if (result.stdout.trim()) parts.push(result.stdout.trim());
-  if (result.stderr.trim()) parts.push(result.stderr.trim());
-  return parts.join("\n") || "No output";
-}
-server.tool(
-  "stale_scan",
-  "Scan for documentation drift \u2014 detect when docs say one thing and code says another",
-  {
-    path: z.string().optional().describe("Project directory to scan (defaults to cwd)"),
-    deep: z.coerce.boolean().optional().describe("Enable AI-powered deep analysis"),
-    git: z.coerce.boolean().optional().describe("Enable git history staleness checks"),
-    format: z.enum(["terminal", "json", "markdown", "sarif"]).optional().describe("Output format")
-  },
-  async ({ path, deep, git, format }) => {
-    const args = ["scan"];
-    if (deep) args.push("--deep");
-    if (git) args.push("--git");
-    if (format) args.push("--format", format);
-    const result = await runCli("stale", args, path);
-    const output = formatOutput(result);
-    writeCache("stale", deriveProject(path), output, result.code);
-    const extras = await checkTriggers("stale_scan", result, path);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "stale_fix",
-  "Auto-fix documentation drift \u2014 generate fixes for wrong file paths, dead links, phantom env vars, outdated scripts",
-  {
-    path: z.string().optional().describe("Project directory to scan (defaults to cwd)"),
-    format: z.enum(["terminal", "diff"]).optional().describe("Output format (default: terminal)"),
-    apply: z.coerce.boolean().optional().describe("Apply high-confidence fixes directly"),
-    dryRun: z.coerce.boolean().optional().describe("Show what --apply would do without writing")
-  },
-  async ({ path, format, apply, dryRun }) => {
-    const args = ["fix"];
-    if (format) args.push("--format", format);
-    if (apply) args.push("--apply");
-    if (dryRun) args.push("--dry-run");
-    const result = await runCli("stale", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "stale_init",
-  "Generate a .stale.yml config file for customizing documentation drift detection",
-  { path: z.string().optional().describe("Project directory (defaults to cwd)") },
-  async ({ path }) => {
-    const result = await runCli("stale", ["init"], path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "envalid_validate",
-  "Validate .env files against their schema \u2014 catch missing or invalid environment variables",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    environment: z.string().optional().describe("Target environment (e.g. production, staging)"),
-    format: z.enum(["terminal", "json", "markdown"]).optional().describe("Output format")
-  },
-  async ({ path, environment, format }) => {
-    const args = ["validate"];
-    if (environment) args.push("--environment", environment);
-    if (format) args.push("--format", format);
-    const result = await runCli("envalid", args, path);
-    const output = formatOutput(result);
-    writeCache("envalid_validate", deriveProject(path), output, result.code);
-    const extras = await checkTriggers("envalid_validate", result, path);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "envalid_detect",
-  "Scan codebase for env var usage and compare with schema \u2014 find undocumented env vars",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    format: z.enum(["terminal", "json"]).optional().describe("Output format")
-  },
-  async ({ path, format }) => {
-    const args = ["detect"];
-    if (format) args.push("--format", format);
-    const result = await runCli("envalid", args, path);
-    const output = formatOutput(result);
-    writeCache("envalid_detect", deriveProject(path), output, result.code);
-    const extras = await checkTriggers("envalid_detect", result, path);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "envalid_init",
-  "Generate .env.schema from an existing .env file \u2014 bootstrap type-safe env validation",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    force: z.coerce.boolean().optional().describe("Overwrite existing schema")
-  },
-  async ({ path, force }) => {
-    const args = ["init"];
-    if (force) args.push("--force");
-    const result = await runCli("envalid", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "envalid_diff",
-  "Compare two .env files \u2014 show added, removed, and changed variables",
-  {
-    source: z.string().describe("Path to source .env file"),
-    target: z.string().describe("Path to target .env file"),
-    schema: z.string().optional().describe("Path to .env.schema for sensitivity info"),
-    format: z.enum(["terminal", "json", "markdown"]).optional().describe("Output format")
-  },
-  async ({ source, target, schema, format }) => {
-    const args = ["diff", source, target];
-    if (schema) args.push("--schema", schema);
-    if (format) args.push("--format", format);
-    const result = await runCli("envalid", args);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "envalid_sync",
-  "Check multiple environment files against schema \u2014 ensure all envs are in sync",
-  {
-    environments: z.string().describe('Comma-separated env file paths (e.g. ".env,.env.staging,.env.production")'),
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    format: z.enum(["terminal", "json", "markdown"]).optional().describe("Output format")
-  },
-  async ({ environments, path, format }) => {
-    const args = ["sync", "--environments", environments];
-    if (format) args.push("--format", format);
-    const result = await runCli("envalid", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "envalid_generate",
-  "Generate .env.example from schema \u2014 create a safe template without secrets",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    output: z.string().optional().describe("Output file path (default: .env.example)")
-  },
-  async ({ path, output }) => {
-    const args = ["generate-example"];
-    if (output) args.push("--output", output);
-    const result = await runCli("envalid", args, path);
-    const outputText = formatOutput(result);
-    return { content: [{ type: "text", text: outputText }] };
-  }
-);
-server.tool(
-  "envalid_secrets",
-  "Scan committed files for leaked secrets \u2014 detect API keys, tokens, passwords in code",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    format: z.enum(["terminal", "json"]).optional().describe("Output format")
-  },
-  async ({ path, format }) => {
-    const args = ["secrets"];
-    if (format) args.push("--format", format);
-    const result = await runCli("envalid", args, path);
-    const output = formatOutput(result);
-    writeCache("envalid_secrets", deriveProject(path), output, result.code);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "envalid_generate_schema",
-  "Generate .env.schema from code analysis \u2014 infer types, required-ness, and sensitivity from usage patterns",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    output: z.string().optional().describe("Output file path (default: .env.schema)")
-  },
-  async ({ path, output }) => {
-    const args = ["detect", "--generate"];
-    if (output) args.push("-o", output);
-    const result = await runCli("envalid", args, path);
-    const outputText = formatOutput(result);
-    return { content: [{ type: "text", text: outputText }] };
-  }
-);
-server.tool(
-  "envalid_hook_status",
-  "Check if the envalid pre-commit git hook is installed",
-  { path: z.string().optional().describe("Project directory (defaults to cwd)") },
-  async ({ path }) => {
-    const result = await runCli("envalid", ["hook", "status"], path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "berth_status",
-  "Show all active ports, Docker ports, and configured ports \u2014 diagnose port conflicts",
-  {},
-  async () => {
-    const result = await runCli("berth", ["status", "--json"]);
-    const output = formatOutput(result);
-    writeCache("berth_status", deriveProject(), output, result.code);
-    const extras = await checkTriggers("berth_status", result);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "berth_check",
-  "Scan a project directory for port conflicts before starting dev servers",
-  { path: z.string().optional().describe("Project directory to check (defaults to cwd)") },
-  async ({ path }) => {
-    const result = await runCli("berth", ["check", path || "."]);
-    const output = formatOutput(result);
-    writeCache("berth_check", deriveProject(path), output, result.code);
-    const extras = await checkTriggers("berth_check", result, path);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "berth_kill",
-  "Kill processes on a specific port \u2014 free up a port for your dev server",
-  {
-    port: z.coerce.number().optional().describe("Port number to free"),
-    dev: z.coerce.boolean().optional().describe("Kill all dev processes (node, python, ruby, etc.)")
-  },
-  async ({ port, dev }) => {
-    const args = ["kill"];
-    if (port) args.push(String(port));
-    if (dev) args.push("--dev");
-    args.push("--force");
-    const result = await runCli("berth", args);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "berth_free",
-  "Free all ports for a registered project \u2014 kill every process blocking the project",
-  { project: z.string().describe("Registered project name") },
-  async ({ project }) => {
-    const result = await runCli("berth", ["free", project]);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "berth_register",
-  "Register a project directory's port requirements for conflict tracking",
-  {
-    path: z.string().optional().describe("Project directory to register (defaults to cwd)")
-  },
-  async ({ path }) => {
-    const args = ["register", "--yes"];
-    if (path) args.push("--dir", path);
-    const result = await runCli("berth", args);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "berth_list",
-  "List all registered projects and their port statuses",
-  {},
-  async () => {
-    const result = await runCli("berth", ["list", "--json"]);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "berth_reassign",
-  "Change a port assignment in project config files (docker-compose, .env, etc.)",
-  {
-    oldPort: z.number().describe("Current port number"),
-    newPort: z.number().describe("New port number"),
-    project: z.string().optional().describe("Project name from registry")
-  },
-  async ({ oldPort, newPort, project }) => {
-    const args = ["reassign", String(oldPort), String(newPort)];
-    if (project) args.push("--project", project);
-    const result = await runCli("berth", args);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "berth_start",
-  "Auto-resolve all port conflicts and prepare a project to start cleanly",
-  {
-    project: z.string().describe("Registered project name"),
-    dryRun: z.coerce.boolean().optional().describe("Show what would be done without making changes")
-  },
-  async ({ project, dryRun }) => {
-    const args = ["start", project];
-    if (dryRun) args.push("--dry-run");
-    const result = await runCli("berth", args);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "berth_resolve",
-  "Auto-resolve port conflicts \u2014 detect conflicts and fix via kill or reassign strategy",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    strategy: z.enum(["kill", "reassign", "auto"]).optional().describe("Resolution strategy (default: auto)"),
-    kill: z.coerce.boolean().optional().describe("Allow killing processes (required for kill/auto strategies)"),
-    dryRun: z.coerce.boolean().optional().describe("Show what would be done without making changes")
-  },
-  async ({ path, strategy, kill, dryRun }) => {
-    const args = ["resolve"];
-    if (strategy) args.push("--strategy", strategy);
-    if (kill) args.push("--kill");
-    if (dryRun) args.push("--dry-run");
-    const result = await runCli("berth", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "berth_predict",
-  "Predict port conflicts from project config files before starting \u2014 dry-run conflict check",
-  { path: z.string().optional().describe("Project directory (defaults to cwd)") },
-  async ({ path }) => {
-    const result = await runCli("berth", ["predict", path || "."]);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "aware_init",
-  "Auto-detect project stack and generate AI context files (CLAUDE.md, .cursorrules, etc.)",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    targets: z.string().optional().describe("Comma-separated targets: claude,cursor,copilot,agents,all"),
-    force: z.coerce.boolean().optional().describe("Overwrite existing files without prompting")
-  },
-  async ({ path, targets, force }) => {
-    const args = ["init"];
-    if (targets) args.push("--targets", targets);
-    if (force) args.push("--force");
-    const result = await runCli("aware", args, path);
-    const output = formatOutput(result);
-    writeCache("aware_init", deriveProject(path), output, result.code);
-    const extras = await checkTriggers("aware_init", result, path);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "aware_sync",
-  "Regenerate AI context files from .aware.json \u2014 update CLAUDE.md, .cursorrules, etc.",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    dryRun: z.coerce.boolean().optional().describe("Show what would change without writing files")
-  },
-  async ({ path, dryRun }) => {
-    const args = ["sync"];
-    if (dryRun) args.push("--dry-run");
-    const result = await runCli("aware", args, path);
-    const output = formatOutput(result);
-    writeCache("aware_sync", deriveProject(path), output, result.code);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "aware_diff",
-  "Show project changes since last sync \u2014 see what drifted in your codebase",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    exitCode: z.coerce.boolean().optional().describe("Return exit code 1 if changes detected (useful for CI)")
-  },
-  async ({ path, exitCode }) => {
-    const args = ["diff"];
-    if (exitCode) args.push("--exit-code");
-    const result = await runCli("aware", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "aware_validate",
-  "Validate .aware.json schema and content \u2014 check for config errors",
-  { path: z.string().optional().describe("Project directory (defaults to cwd)") },
-  async ({ path }) => {
-    const result = await runCli("aware", ["validate"], path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "aware_doctor",
-  "Diagnose project health \u2014 check config issues, stack drift, stale AI context files",
-  { path: z.string().optional().describe("Project directory (defaults to cwd)") },
-  async ({ path }) => {
-    const result = await runCli("aware", ["doctor"], path);
-    const output = formatOutput(result);
-    writeCache("aware_doctor", deriveProject(path), output, result.code);
-    const extras = await checkTriggers("aware_doctor", result, path);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "aware_add",
-  "Add a rule, convention, or structure entry to .aware.json",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    type: z.enum(["rule", "convention", "structure"]).describe("Type to add")
-  },
-  async ({ path, type }) => {
-    const args = ["add", "--type", type];
-    const result = await runCli("aware", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "vow_scan",
-  "Scan dependency licenses \u2014 summarize all licenses in the project",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    production: z.coerce.boolean().optional().describe("Skip devDependencies"),
-    format: z.enum(["terminal", "json"]).optional().describe("Output format")
-  },
-  async ({ path, production, format }) => {
-    const args = ["scan"];
-    if (production) args.push("--production");
-    if (format) args.push("--format", format);
-    const result = await runCli("vow", args, path);
-    const output = formatOutput(result);
-    writeCache("vow_scan", deriveProject(path), output, result.code);
-    const extras = await checkTriggers("vow_scan", result, path);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "vow_check",
-  "Validate dependency licenses against policy \u2014 flag violations before release",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    production: z.coerce.boolean().optional().describe("Skip devDependencies")
-  },
-  async ({ path, production }) => {
-    const args = ["check"];
-    if (production) args.push("--production");
-    const result = await runCli("vow", args, path);
-    const output = formatOutput(result);
-    writeCache("vow_check", deriveProject(path), output, result.code);
-    const extras = await checkTriggers("vow_check", result, path);
-    return { content: [{ type: "text", text: output + extras.join("") }] };
-  }
-);
-server.tool(
-  "vow_init",
-  "Generate a license policy file (.vow.json) \u2014 choose from commercial, opensource, or strict templates",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    template: z.enum(["commercial", "opensource", "strict"]).optional().describe("Policy template")
-  },
-  async ({ path, template }) => {
-    const args = ["init"];
-    if (template) args.push("--template", template);
-    const result = await runCli("vow", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "vow_tree",
-  "Display dependency tree with license annotations \u2014 trace license inheritance",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    filter: z.string().optional().describe('Show only subtrees containing this license (e.g. "GPL")'),
-    depth: z.coerce.number().optional().describe("Max tree depth"),
-    production: z.coerce.boolean().optional().describe("Skip devDependencies")
-  },
-  async ({ path, filter, depth, production }) => {
-    const args = ["tree"];
-    if (path) args.push("--path", path);
-    if (filter) args.push("--filter", filter);
-    if (depth) args.push("--depth", String(depth));
-    if (production) args.push("--production");
-    const result = await runCli("vow", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "vow_fix",
-  "Suggest alternative packages for license policy violations \u2014 find compliant replacements",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    production: z.coerce.boolean().optional().describe("Skip devDependencies"),
-    limit: z.coerce.number().optional().describe("Max alternatives per package")
-  },
-  async ({ path, production, limit }) => {
-    const args = ["fix"];
-    if (path) args.push("--path", path);
-    if (production) args.push("--production");
-    if (limit) args.push("--limit", String(limit));
-    const result = await runCli("vow", args, path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "vow_export",
-  "Export full license report as JSON, CSV, or Markdown",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    format: z.enum(["json", "csv", "markdown"]).optional().describe("Export format (default: json)"),
-    output: z.string().optional().describe("Output file path"),
-    production: z.coerce.boolean().optional().describe("Skip devDependencies")
-  },
-  async ({ path, format, output, production }) => {
-    const args = ["export"];
-    if (path) args.push("--path", path);
-    if (format) args.push("--format", format);
-    if (output) args.push("--output", output);
-    if (production) args.push("--production");
-    const result = await runCli("vow", args, path);
-    const outputText = formatOutput(result);
-    return { content: [{ type: "text", text: outputText }] };
-  }
-);
-server.tool(
-  "vow_hook_install",
-  "Install a pre-commit git hook that checks dependency licenses before each commit",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)")
-  },
-  async ({ path }) => {
-    const result = await runCli("vow", ["hook", "install"], path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "vow_hook_uninstall",
-  "Remove the vow pre-commit license check hook",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)")
-  },
-  async ({ path }) => {
-    const result = await runCli("vow", ["hook", "uninstall"], path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "vow_hook_status",
-  "Check if the vow pre-commit license check hook is installed",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)")
-  },
-  async ({ path }) => {
-    const result = await runCli("vow", ["hook", "status"], path);
-    const output = formatOutput(result);
-    return { content: [{ type: "text", text: output }] };
-  }
-);
-server.tool(
-  "vow_attribution",
-  "Generate THIRD_PARTY_LICENSES.md \u2014 list all dependencies with their licenses for compliance",
-  {
-    path: z.string().optional().describe("Project directory (defaults to cwd)"),
-    output: z.string().optional().describe("Output file (default: THIRD_PARTY_LICENSES.md)"),
-    production: z.coerce.boolean().optional().describe("Skip devDependencies")
-  },
-  async ({ path, output, production }) => {
-    const args = ["attribution"];
-    if (path) args.push("--path", path);
-    if (output) args.push("--output", output);
-    if (production) args.push("--production");
-    const result = await runCli("vow", args, path);
-    const outputText = formatOutput(result);
-    return { content: [{ type: "text", text: outputText }] };
-  }
-);
+registerStaleTools(server);
+registerEnvalidTools(server);
+registerBerthTools(server);
+registerAwareTools(server);
+registerVowTools(server);
 process.on("SIGINT", () => {
   velocityDb.close();
   process.exit(0);