claudectx 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -1277,6 +1277,9 @@ function detectRedundantContent(claudeMdContent, memoryContent) {
 // src/analyzer/cost-calculator.ts
 init_esm_shims();
 init_models();
+function tokenCost(tokens, model) {
+  return calculateCost(tokens, model);
+}
 function sessionCost(tokensPerRequest, model) {
   const perRequest = calculateCost(tokensPerRequest, model);
   return {
@@ -1899,6 +1902,14 @@ function applyHooksInstall(result) {
   }
   fs6.writeFileSync(result.settingsPath, JSON.stringify(result.mergedSettings, null, 2) + "\n", "utf-8");
 }
+function writeHooksSettings(projectRoot, mergedSettings) {
+  const settingsPath = path7.join(projectRoot, ".claude", "settings.local.json");
+  const dir = path7.dirname(settingsPath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
+  }
+  fs6.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n", "utf-8");
+}
 function isAlreadyInstalled(projectRoot) {
   const settingsPath = path7.join(projectRoot, ".claude", "settings.local.json");
   if (!fs6.existsSync(settingsPath)) return false;
@@ -2214,12 +2225,12 @@ async function handleLogStdin() {
   }
 }
 function readStdin() {
-  return new Promise((resolve6) => {
+  return new Promise((resolve11) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve6(data));
-    setTimeout(() => resolve6(data), 500);
+    process.stdin.on("end", () => resolve11(data));
+    setTimeout(() => resolve11(data), 500);
   });
 }
 
@@ -2473,8 +2484,8 @@ async function summariseWithAI(conversationText, apiKey) {
   if (!key) {
     throw new Error("No API key available");
   }
-  const { default: Anthropic } = await import("@anthropic-ai/sdk");
-  const client = new Anthropic({ apiKey: key });
+  const { default: Anthropic2 } = await import("@anthropic-ai/sdk");
+  const client = new Anthropic2({ apiKey: key });
   const response = await client.messages.create({
     model: SUMMARY_MODEL,
     max_tokens: SUMMARY_MAX_TOKENS,
@@ -2981,6 +2992,1273 @@ async function reportCommand(options) {
   process.stdout.write(output + "\n");
 }
 
+// src/commands/budget.ts
+init_esm_shims();
+import * as path21 from "path";
+
+// src/analyzer/budget-estimator.ts
+init_esm_shims();
+init_tokenizer();
+import * as fs17 from "fs";
+import * as path20 from "path";
+import { glob as glob2 } from "glob";
+init_session_store();
+function resolveGlobs(globs, projectRoot) {
+  const results = [];
+  for (const pattern of globs) {
+    try {
+      const matches = glob2.sync(pattern, {
+        cwd: projectRoot,
+        absolute: true,
+        nodir: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/*.min.js"]
+      });
+      results.push(...matches);
+    } catch {
+    }
+  }
+  return [...new Set(results)];
+}
+function classifyCacheHit(recentReadCount) {
+  if (recentReadCount >= 3) return "high";
+  if (recentReadCount >= 1) return "medium";
+  return "low";
+}
+function suggestClaudeignoreAdditions(files, projectRoot) {
+  const ignorePath = path20.join(projectRoot, ".claudeignore");
+  let ignorePatterns = [];
+  try {
+    const content = fs17.readFileSync(ignorePath, "utf-8");
+    ignorePatterns = content.split("\n").filter(Boolean);
+  } catch {
+  }
+  const recommendations = [];
+  for (const file of files) {
+    if (file.tokenCount <= WASTE_THRESHOLDS.MAX_REFERENCE_FILE_TOKENS) continue;
+    const rel = path20.relative(projectRoot, file.filePath);
+    const alreadyIgnored = ignorePatterns.some((pattern) => {
+      const cleanPattern = pattern.replace(/^!/, "");
+      return rel.startsWith(cleanPattern.replace(/\*/g, "").replace(/\//g, path20.sep));
+    });
+    if (!alreadyIgnored) {
+      recommendations.push(rel);
+    }
+  }
+  return recommendations;
+}
+async function estimateBudget(globs, projectRoot, model, thresholdTokens) {
+  const filePaths = resolveGlobs(globs, projectRoot);
+  const events = readAllEvents();
+  const readCounts = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const count = readCounts.get(event.filePath) ?? 0;
+    readCounts.set(event.filePath, count + 1);
+  }
+  const files = [];
+  for (const filePath of filePaths) {
+    let content = "";
+    try {
+      content = fs17.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const tokenCount = countTokens(content);
+    const recentReadCount = readCounts.get(filePath) ?? 0;
+    const cacheHitLikelihood = classifyCacheHit(recentReadCount);
+    const estimatedCostUsd = tokenCost(tokenCount, model);
+    files.push({
+      filePath,
+      tokenCount,
+      recentReadCount,
+      cacheHitLikelihood,
+      estimatedCostUsd
+    });
+  }
+  files.sort((a, b) => b.tokenCount - a.tokenCount);
+  const totalTokens = files.reduce((sum, f) => sum + f.tokenCount, 0);
+  const totalEstimatedCostUsd = tokenCost(totalTokens, model);
+  const CACHE_WEIGHTS = { high: 0.85, medium: 0.5, low: 0 };
+  let weightedSum = 0;
+  for (const f of files) {
+    weightedSum += f.tokenCount * CACHE_WEIGHTS[f.cacheHitLikelihood];
+  }
+  const cacheHitPotential = totalTokens > 0 ? Math.round(weightedSum / totalTokens * 100) : 0;
+  const claudeignoreRecommendations = suggestClaudeignoreAdditions(files, projectRoot);
+  return {
+    globs,
+    model,
+    files,
+    totalTokens,
+    totalEstimatedCostUsd,
+    thresholdExceeded: totalTokens > thresholdTokens,
+    thresholdTokens,
+    cacheHitPotential,
+    claudeignoreRecommendations
+  };
+}
+function formatBudgetReport(report) {
+  const lines = [];
+  lines.push("");
+  lines.push("claudectx budget \u2014 context cost estimate");
+  lines.push("\u2550".repeat(50));
+  if (report.files.length === 0) {
+    lines.push("No files matched the given glob patterns.");
+    return lines.join("\n");
+  }
+  const LIKELIHOOD_ICON = { high: "\u{1F7E2}", medium: "\u{1F7E1}", low: "\u{1F534}" };
+  const maxPathLen = Math.min(
+    Math.max(...report.files.map((f) => path20.basename(f.filePath).length)),
+    40
+  );
+  lines.push(
+    `  ${"File".padEnd(maxPathLen)}  ${"Tokens".padStart(7)}  Cache    Cost`
+  );
+  lines.push("\u2500".repeat(50));
+  for (const file of report.files.slice(0, 20)) {
+    const name = path20.basename(file.filePath).slice(0, maxPathLen).padEnd(maxPathLen);
+    const tokens = file.tokenCount.toLocaleString().padStart(7);
+    const cache = `${LIKELIHOOD_ICON[file.cacheHitLikelihood]} ${file.cacheHitLikelihood.padEnd(6)}`;
+    const cost = formatCost(file.estimatedCostUsd).padStart(7);
+    lines.push(`  ${name}  ${tokens}  ${cache}  ${cost}`);
+  }
+  if (report.files.length > 20) {
+    lines.push(`  ... and ${report.files.length - 20} more files`);
+  }
+  lines.push("\u2500".repeat(50));
+  const thresholdStatus = report.thresholdExceeded ? `\u26A0  EXCEEDS threshold (${report.thresholdTokens.toLocaleString()} tokens)` : `\u2713  Within threshold (${report.thresholdTokens.toLocaleString()} tokens)`;
+  lines.push(`  Total tokens:     ${report.totalTokens.toLocaleString().padStart(10)}`);
+  lines.push(`  Estimated cost:   ${formatCost(report.totalEstimatedCostUsd).padStart(10)}`);
+  lines.push(`  Cache potential:  ${`${report.cacheHitPotential}%`.padStart(10)}`);
+  lines.push(`  ${thresholdStatus}`);
+  if (report.claudeignoreRecommendations.length > 0) {
+    lines.push("");
+    lines.push("  \u{1F4A1} Add to .claudeignore to exclude large files:");
+    for (const rec of report.claudeignoreRecommendations.slice(0, 5)) {
+      lines.push(`     ${rec}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/budget.ts
+init_models();
+async function budgetCommand(globs, options) {
+  const projectPath = options.path ? path21.resolve(options.path) : process.cwd();
+  const projectRoot = findProjectRoot(projectPath) ?? projectPath;
+  const model = resolveModel(options.model ?? "sonnet");
+  const thresholdTokens = parseInt(options.threshold ?? "10000", 10);
+  if (globs.length === 0) {
+    process.stderr.write("Error: at least one glob pattern is required.\n");
+    process.stderr.write('Example: claudectx budget "src/**/*.ts"\n');
+    process.exit(1);
+  }
+  const report = await estimateBudget(globs, projectRoot, model, thresholdTokens);
+  if (options.json) {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write(formatBudgetReport(report));
+}
+
+// src/commands/warmup.ts
+init_esm_shims();
+import * as path22 from "path";
+import Anthropic from "@anthropic-ai/sdk";
+init_models();
+import fs18 from "fs";
+function buildWarmupMessages(claudeMdContent) {
+  const systemBlock = {
+    type: "text",
+    text: claudeMdContent || "# Project\nNo CLAUDE.md found.",
+    // @ts-expect-error — cache_control is valid but not yet in the TS types for all SDKs
+    cache_control: { type: "ephemeral" }
+  };
+  return {
+    system: [systemBlock],
+    messages: [
+      {
+        role: "user",
+        content: "ping"
+      }
+    ]
+  };
+}
+function calculateBreakEven(writeTokens, model, ttlMinutes) {
+  const pricing = MODEL_PRICING[model];
+  const writeMultiplier = ttlMinutes === 60 ? 2 : 1.25;
+  const writeCostPerMillion = pricing.inputPerMillion * writeMultiplier;
+  const writeCostUsd = writeTokens / 1e6 * writeCostPerMillion;
+  const readCostUsd = writeTokens / 1e6 * pricing.cacheReadPerMillion;
+  const inputCostUsd = writeTokens / 1e6 * pricing.inputPerMillion;
+  const savingsPerHit = inputCostUsd - readCostUsd;
+  const breakEvenRequests = savingsPerHit > 0 ? Math.ceil(writeCostUsd / savingsPerHit) : 999;
+  return { breakEvenRequests, savingsPerHit, writeCostUsd };
+}
+async function executeWarmup(claudeMdContent, model, ttl, client) {
+  const { system, messages } = buildWarmupMessages(claudeMdContent);
+  const betas = ["prompt-caching-2024-07-31"];
+  if (ttl === 60) betas.push("extended-cache-ttl-2025-02-19");
+  const response = await client.beta.messages.create({
+    model,
+    max_tokens: 8,
+    system,
+    messages,
+    betas
+  });
+  const usage = response.usage;
+  const tokensWarmed = usage.cache_creation_input_tokens ?? 0;
+  const { breakEvenRequests, savingsPerHit, writeCostUsd } = calculateBreakEven(
+    tokensWarmed,
+    model,
+    ttl
+  );
+  return {
+    model,
+    tokensWarmed,
+    cacheWriteCostUsd: writeCostUsd,
+    estimatedSavingsPerHit: savingsPerHit,
+    breakEvenRequests,
+    ttlMinutes: ttl,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function installCron(cronExpr, apiKey) {
+  const { execSync: execSync3 } = await import("child_process");
+  const command = `claudectx warmup --api-key ${apiKey}`;
+  const cronLine = `${cronExpr} ${command}`;
+  try {
+    let existing = "";
+    try {
+      existing = execSync3("crontab -l 2>/dev/null", { encoding: "utf-8" });
+    } catch {
+      existing = "";
+    }
+    if (existing.includes("claudectx warmup")) {
+      process.stdout.write("Cron job already installed for claudectx warmup.\n");
+      return;
+    }
+    const newCrontab = existing.trimEnd() + "\n" + cronLine + "\n";
+    execSync3(`echo ${JSON.stringify(newCrontab)} | crontab -`);
+    process.stdout.write(`\u2713 Cron job installed: ${cronLine}
+`);
+  } catch {
+    process.stdout.write(`Could not install cron automatically. Add manually:
+  ${cronLine}
+`);
+  }
+}
+async function warmupCommand(options) {
+  const projectPath = options.path ? path22.resolve(options.path) : process.cwd();
+  const projectRoot = findProjectRoot(projectPath) ?? projectPath;
+  const model = resolveModel(options.model ?? "haiku");
+  const ttl = options.ttl === "60" ? 60 : 5;
+  const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    process.stderr.write(
+      "Error: Anthropic API key required. Use --api-key or set ANTHROPIC_API_KEY.\n"
+    );
+    process.exit(1);
+  }
+  let claudeMdContent = "";
+  const claudeMdPath = path22.join(projectRoot, "CLAUDE.md");
+  try {
+    claudeMdContent = fs18.readFileSync(claudeMdPath, "utf-8");
+  } catch {
+    process.stderr.write(`Warning: No CLAUDE.md found at ${claudeMdPath}
+`);
+  }
+  const client = new Anthropic({ apiKey });
+  if (!options.json) {
+    process.stdout.write(`Warming up prompt cache (model: ${model}, TTL: ${ttl}min)...
+`);
+  }
+  let result;
+  try {
+    result = await executeWarmup(claudeMdContent, model, ttl, client);
+  } catch (err) {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+  if (options.json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write("\n");
+  process.stdout.write("claudectx warmup \u2014 prompt cache primed\n");
+  process.stdout.write("\u2550".repeat(45) + "\n");
+  process.stdout.write(`  Model:              ${result.model}
+`);
+  process.stdout.write(`  Tokens warmed:      ${result.tokensWarmed.toLocaleString()}
+`);
+  process.stdout.write(`  Cache write cost:   ${formatCost(result.cacheWriteCostUsd)}
+`);
+  process.stdout.write(`  Savings per hit:    ${formatCost(result.estimatedSavingsPerHit)}
+`);
+  process.stdout.write(`  Break-even after:   ${result.breakEvenRequests} requests
+`);
+  process.stdout.write(`  TTL:                ${result.ttlMinutes} minutes
+`);
+  process.stdout.write("\n");
+  if (result.tokensWarmed === 0) {
+    process.stdout.write(
+      `  \u26A0  No tokens were cached. CLAUDE.md may be below the minimum token threshold
+     (${model === "claude-haiku-4-5" ? "4,096" : "1,024"} tokens for ${model}).
+`
+    );
+  } else {
+    process.stdout.write(
+      `  \u2713  First ${result.ttlMinutes === 60 ? "60-minute" : "5-minute"} window of requests will benefit from cache hits.
+`
+    );
+  }
+  process.stdout.write("\n");
+  if (options.cron) {
+    await installCron(options.cron, apiKey);
+  }
+}
+
+// src/commands/drift.ts
+init_esm_shims();
+import * as path24 from "path";
+import * as fs20 from "fs";
+
+// src/analyzer/drift-detector.ts
+init_esm_shims();
+init_tokenizer();
+init_session_store();
+import * as fs19 from "fs";
+import * as path23 from "path";
+import * as childProcess from "child_process";
+var INLINE_PATH_RE = /(?:^|\s)((?:\.{1,2}\/|src\/|lib\/|docs\/|app\/|tests?\/)\S+\.\w{1,6})/gm;
+var AT_REF_RE = /^@(.+)$/;
+function findDeadAtReferences(content, projectRoot) {
+  const issues = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(AT_REF_RE);
+    if (!match) continue;
+    const ref = match[1].trim();
+    const absPath = path23.isAbsolute(ref) ? ref : path23.join(projectRoot, ref);
+    if (!fs19.existsSync(absPath)) {
+      const lineText = lines[i];
+      issues.push({
+        type: "dead-ref",
+        line: i + 1,
+        text: lineText,
+        severity: "error",
+        estimatedTokenWaste: countTokens(lineText),
+        suggestion: `File "${ref}" does not exist. Remove this @reference or update the path.`
+      });
+    }
+  }
+  return issues;
+}
+async function findGitDeletedMentions(content, projectRoot) {
+  const issues = [];
+  let deletedFiles = /* @__PURE__ */ new Set();
+  try {
+    const output = childProcess.execSync(
+      "git log --diff-filter=D --name-only --pretty=format: --",
+      { cwd: projectRoot, encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    deletedFiles = new Set(
+      output.split("\n").map((f) => f.trim()).filter(Boolean)
+    );
+  } catch {
+    return [];
+  }
+  if (deletedFiles.size === 0) return [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const deleted of deletedFiles) {
+      const basename7 = path23.basename(deleted);
+      if (line.includes(basename7) || line.includes(deleted)) {
+        issues.push({
+          type: "git-deleted",
+          line: i + 1,
+          text: line.trim(),
+          severity: "warning",
+          estimatedTokenWaste: countTokens(line),
+          suggestion: `References "${basename7}" which was deleted from git. Consider removing this mention.`
+        });
+        break;
+      }
+    }
+  }
+  return issues;
+}
+function findStaleSections(content, events, dayWindow) {
+  const issues = [];
+  const cutoff = Date.now() - dayWindow * 24 * 60 * 60 * 1e3;
+  const recentEvents = events.filter((e) => new Date(e.timestamp).getTime() >= cutoff);
+  const recentPaths = new Set(
+    recentEvents.map((e) => e.filePath.toLowerCase())
+  );
+  const lines = content.split("\n");
+  const sections = [];
+  let currentSection = null;
+  for (let i = 0; i < lines.length; i++) {
+    const sectionMatch = lines[i].match(/^#{1,3}\s+(.+)$/);
+    if (sectionMatch) {
+      if (currentSection) sections.push(currentSection);
+      currentSection = { line: i + 1, header: sectionMatch[1], bodyLines: [] };
+    } else if (currentSection) {
+      currentSection.bodyLines.push(lines[i]);
+    }
+  }
+  if (currentSection) sections.push(currentSection);
+  for (const section of sections) {
+    const headerWords = section.header.toLowerCase().split(/\W+/).filter((w) => w.length > 3);
+    const matched = headerWords.some(
+      (word) => [...recentPaths].some((p) => {
+        if (p.includes(word)) return true;
+        const segments = p.split(/[/\\.]/).filter((s) => s.length >= 4);
+        return segments.some((seg) => word.startsWith(seg) || seg.startsWith(word));
+      })
+    );
+    if (!matched && recentEvents.length > 0) {
+      const sectionContent = section.bodyLines.join("\n");
+      issues.push({
+        type: "stale-section",
+        line: section.line,
+        text: `## ${section.header}`,
+        severity: "info",
+        estimatedTokenWaste: countTokens(`## ${section.header}
+${sectionContent}`),
+        suggestion: `Section "## ${section.header}" had no matching file reads in the last ${dayWindow} days. Consider removing or archiving it.`
+      });
+    }
+  }
+  return issues;
+}
+function findDeadInlinePaths(content, projectRoot) {
+  const issues = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (AT_REF_RE.test(line)) continue;
+    let match;
+    INLINE_PATH_RE.lastIndex = 0;
+    const seen = /* @__PURE__ */ new Set();
+    while ((match = INLINE_PATH_RE.exec(line)) !== null) {
+      const rawPath = match[1].trim();
+      if (seen.has(rawPath)) continue;
+      seen.add(rawPath);
+      const absPath = path23.isAbsolute(rawPath) ? rawPath : path23.join(projectRoot, rawPath);
+      if (!fs19.existsSync(absPath)) {
+        issues.push({
+          type: "dead-inline-path",
+          line: i + 1,
+          text: line.trim(),
+          severity: "warning",
+          estimatedTokenWaste: countTokens(rawPath),
+          suggestion: `Path "${rawPath}" no longer exists. Update or remove this reference.`
+        });
+        break;
+      }
+    }
+  }
+  return issues;
+}
+async function detectDrift(projectRoot, dayWindow) {
+  const claudeMdPath = path23.join(projectRoot, "CLAUDE.md");
+  let content = "";
+  try {
+    content = fs19.readFileSync(claudeMdPath, "utf-8");
+  } catch {
+    return {
+      claudeMdPath,
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      dayWindow,
+      issues: [],
+      totalWastedTokens: 0
+    };
+  }
+  const events = readAllEvents();
+  const [deadRefs, gitDeleted, staleSections, deadInlinePaths] = await Promise.all([
+    Promise.resolve(findDeadAtReferences(content, projectRoot)),
+    findGitDeletedMentions(content, projectRoot),
+    Promise.resolve(findStaleSections(content, events, dayWindow)),
+    Promise.resolve(findDeadInlinePaths(content, projectRoot))
+  ]);
+  const allIssues = [...deadRefs, ...gitDeleted, ...staleSections, ...deadInlinePaths];
+  allIssues.sort((a, b) => a.line - b.line);
+  const totalWastedTokens = allIssues.reduce((sum, i) => sum + i.estimatedTokenWaste, 0);
+  return {
+    claudeMdPath,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dayWindow,
+    issues: allIssues,
+    totalWastedTokens
+  };
+}
+
+// src/commands/drift.ts
+var SEVERITY_ICON = {
+  error: "\u2716",
+  warning: "\u26A0",
+  info: "\xB7"
+};
+var TYPE_LABEL = {
+  "dead-ref": "Dead @ref",
+  "git-deleted": "Git deleted",
+  "stale-section": "Stale section",
+  "dead-inline-path": "Dead path"
+};
+async function driftCommand(options) {
+  const projectPath = options.path ? path24.resolve(options.path) : process.cwd();
+  const projectRoot = findProjectRoot(projectPath) ?? projectPath;
+  const dayWindow = parseInt(options.days ?? "30", 10);
+  const report = await detectDrift(projectRoot, dayWindow);
+  if (options.json) {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write("\n");
+  process.stdout.write("claudectx drift \u2014 CLAUDE.md staleness check\n");
+  process.stdout.write("\u2550".repeat(55) + "\n");
+  process.stdout.write(`  File:  ${report.claudeMdPath}
+`);
+  process.stdout.write(`  Window: last ${report.dayWindow} days
+`);
+  process.stdout.write("\n");
+  if (report.issues.length === 0) {
+    process.stdout.write("  \u2713 No drift detected. CLAUDE.md looks clean.\n\n");
+    return;
+  }
+  process.stdout.write(
+    `  ${"Line".padEnd(5)}  ${"Type".padEnd(14)}  ${"Waste".padStart(6)}  Issue
+`
+  );
+  process.stdout.write("\u2500".repeat(55) + "\n");
+  for (const issue of report.issues) {
+    const icon = SEVERITY_ICON[issue.severity];
+    const typeLabel = TYPE_LABEL[issue.type].padEnd(14);
+    const waste = `${issue.estimatedTokenWaste}t`.padStart(6);
+    const lineNum = String(issue.line).padEnd(5);
+    const text = issue.text.slice(0, 40);
+    process.stdout.write(`  ${lineNum}  ${typeLabel}  ${waste}  ${icon} ${text}
+`);
+  }
+  process.stdout.write("\u2500".repeat(55) + "\n");
+  process.stdout.write(
+    `  ${report.issues.length} issue(s) found \xB7 ~${report.totalWastedTokens} tokens wasted
+`
+  );
+  process.stdout.write("\n");
+  if (report.issues.length > 0) {
+    process.stdout.write("  Suggestions:\n");
+    const shown = /* @__PURE__ */ new Set();
+    for (const issue of report.issues.slice(0, 5)) {
+      if (!shown.has(issue.suggestion)) {
+        process.stdout.write(`    Line ${issue.line}: ${issue.suggestion}
+`);
+        shown.add(issue.suggestion);
+      }
+    }
+    process.stdout.write("\n");
+  }
+  if (options.fix && report.issues.length > 0) {
+    await applyFix(report.claudeMdPath, report.issues);
+  } else if (report.issues.length > 0 && !options.fix) {
+    process.stdout.write("  Run with --fix to interactively remove flagged lines.\n\n");
+  }
+}
+async function applyFix(claudeMdPath, issues) {
+  const { checkbox: checkbox2 } = await import("@inquirer/prompts").catch(() => {
+    process.stderr.write("Error: @inquirer/prompts is required for --fix mode. Run: npm install -g @inquirer/prompts\n");
+    process.exit(1);
+  });
+  const choices = issues.map((issue) => ({
+    name: `Line ${issue.line}: ${issue.text.slice(0, 60)} (${issue.estimatedTokenWaste}t)`,
+    value: issue.line,
+    checked: issue.severity === "error"
+  }));
+  const selectedLines = await checkbox2({
+    message: "Select lines to remove from CLAUDE.md:",
+    choices
+  });
+  if (selectedLines.length === 0) {
+    process.stdout.write("No lines selected. Nothing changed.\n");
+    return;
+  }
+  const content = fs20.readFileSync(claudeMdPath, "utf-8");
+  const lines = content.split("\n");
+  const lineSet = new Set(selectedLines.map((l) => l - 1));
+  const newLines = lines.filter((_, i) => !lineSet.has(i));
+  fs20.writeFileSync(claudeMdPath, newLines.join("\n"), "utf-8");
+  process.stdout.write(`
+  \u2713 Removed ${selectedLines.length} line(s) from ${claudeMdPath}
+
+`);
+}
+
+// src/commands/hooks.ts
+init_esm_shims();
+import * as fs21 from "fs";
+import * as path25 from "path";
+
+// src/hooks/registry.ts
+init_esm_shims();
+var HOOK_REGISTRY = [
+  {
+    name: "auto-compress",
+    description: "Compress session when token count exceeds threshold",
+    triggerEvent: "PostToolUse",
+    matcher: "Read",
+    commandTemplate: "claudectx compress --auto --api-key {{config.apiKey}}",
+    configSchema: {
+      threshold: { type: "number", default: 5e4, description: "Token threshold to trigger compression" },
+      apiKey: { type: "string", description: "Anthropic API key for AI summarization", required: true }
+    },
+    category: "compression"
+  },
+  {
+    name: "daily-budget",
+    description: "Warn when daily spend exceeds a dollar limit",
+    triggerEvent: "PreToolUse",
+    commandTemplate: "claudectx report --days 1 --json",
+    configSchema: {
+      dailyLimit: { type: "number", default: 5, description: "Daily spend limit in USD" }
+    },
+    category: "budget"
+  },
+  {
+    name: "slack-digest",
+    description: "POST daily usage summary to a Slack incoming webhook",
+    triggerEvent: "Stop",
+    commandTemplate: 'claudectx report --json | curl -s -X POST -H "Content-Type: application/json" --data-binary @- {{config.webhookUrl}}',
+    configSchema: {
+      webhookUrl: {
+        type: "string",
+        description: "Slack Incoming Webhook URL",
+        required: true
+      }
+    },
+    category: "notification"
+  },
+  {
+    name: "session-warmup",
+    description: "Pre-warm the Anthropic prompt cache on each session start",
+    triggerEvent: "PostToolUse",
+    matcher: "Read",
+    commandTemplate: "claudectx warmup --api-key {{config.apiKey}}",
+    configSchema: {
+      apiKey: { type: "string", description: "Anthropic API key", required: true }
+    },
+    category: "warmup"
+  }
+];
+function getHook(name) {
+  return HOOK_REGISTRY.find((h) => h.name === name);
+}
+function interpolateCommand(template, config) {
+  return template.replace(/\{\{config\.(\w+)\}\}/g, (_, key) => {
+    const val = config[key];
+    return val !== void 0 ? String(val) : `{{config.${key}}}`;
+  });
+}
+function buildHookEntry(def, config) {
+  const command = interpolateCommand(def.commandTemplate, config);
+  const hookItem = {
+    type: "command",
+    command
+  };
+  const entry = { hooks: [hookItem] };
+  if (def.matcher) {
+    entry.matcher = def.matcher;
+  }
+  return entry;
+}
+
+// src/commands/hooks.ts
+function readInstalledHooks(projectRoot) {
+  const settingsPath = path25.join(projectRoot, ".claude", "settings.local.json");
+  try {
+    return JSON.parse(fs21.readFileSync(settingsPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function removeHookByName(settings, name) {
+  const hooks = settings.hooks ?? {};
+  const updated = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    updated[event] = entries.filter((entry) => {
+      const hookItems = entry.hooks ?? [];
+      return !hookItems.some((h) => h.command?.includes(`claudectx`) && entry.name === name);
+    });
+  }
+  return { ...settings, hooks: updated };
+}
+function parseConfigPairs(pairs) {
+  const result = {};
+  for (const pair of pairs) {
+    const idx = pair.indexOf("=");
+    if (idx === -1) continue;
+    const key = pair.slice(0, idx).trim();
+    const value = pair.slice(idx + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+async function hooksList(projectRoot) {
+  const settings = readInstalledHooks(projectRoot);
+  const installedCommands = JSON.stringify(settings.hooks ?? {});
+  process.stdout.write("\n");
+  process.stdout.write("claudectx hooks \u2014 available hooks\n");
+  process.stdout.write("\u2550".repeat(55) + "\n");
+  process.stdout.write(
+    `  ${"Name".padEnd(16)}  ${"Category".padEnd(12)}  ${"Trigger".padEnd(12)}  Status
+`
+  );
+  process.stdout.write("\u2500".repeat(55) + "\n");
+  for (const hook of HOOK_REGISTRY) {
+    const installed = installedCommands.includes(hook.name) ? "\u2713 installed" : "  available";
+    process.stdout.write(
+      `  ${hook.name.padEnd(16)}  ${hook.category.padEnd(12)}  ${hook.triggerEvent.padEnd(12)}  ${installed}
+`
+    );
+  }
+  process.stdout.write("\n");
+  process.stdout.write("  Use: claudectx hooks add <name> [--config key=value]\n\n");
+}
+async function hooksAdd(name, projectRoot, configPairs) {
+  const def = getHook(name);
+  if (!def) {
+    process.stderr.write(
+      `Error: unknown hook "${name}". Run "claudectx hooks list" to see available hooks.
+`
+    );
+    process.exit(1);
+  }
+  const config = parseConfigPairs(configPairs);
+  const requiredMissing = Object.entries(def.configSchema).filter(
+    ([key, field]) => field.required && config[key] === void 0
+  );
+  if (requiredMissing.length > 0) {
+    try {
+      const { input } = await import("@inquirer/prompts");
+      for (const [key, field] of requiredMissing) {
+        const value = await input({ message: `${field.description} (${key}):` });
+        config[key] = value;
+      }
+    } catch {
+      process.stderr.write(
+        `Error: required config fields missing: ${requiredMissing.map(([k]) => k).join(", ")}
+  Use: claudectx hooks add ${name} --config ${requiredMissing.map(([k]) => `${k}=<value>`).join(" --config ")}
+`
+      );
+      process.exit(1);
+    }
+  }
+  for (const [key, field] of Object.entries(def.configSchema)) {
+    if (config[key] === void 0 && field.default !== void 0) {
+      config[key] = String(field.default);
+    }
+  }
+  const command = interpolateCommand(def.commandTemplate, config);
+  if (command.includes("{{config.")) {
+    process.stderr.write(`Error: unresolved config placeholders in command: ${command}
+`);
+    process.exit(1);
+  }
+  const entry = { ...buildHookEntry(def, config), name };
+  const settings = readInstalledHooks(projectRoot);
+  const hooksObj = settings.hooks ?? {};
+  const eventList = hooksObj[def.triggerEvent] ?? [];
+  if (eventList.some((e) => e.name === name)) {
+    process.stdout.write(`Hook "${name}" is already installed.
+`);
+    return;
+  }
+  const updatedSettings = {
+    ...settings,
+    hooks: { ...hooksObj, [def.triggerEvent]: [...eventList, entry] }
+  };
+  writeHooksSettings(projectRoot, updatedSettings);
+  process.stdout.write(`
+  \u2713 Hook "${name}" installed (${def.triggerEvent}${def.matcher ? ` / ${def.matcher}` : ""}).
+
+`);
+}
+async function hooksRemove(name, projectRoot) {
+  const settings = readInstalledHooks(projectRoot);
+  const updated = removeHookByName(settings, name);
+  writeHooksSettings(projectRoot, updated);
+  process.stdout.write(`  \u2713 Hook "${name}" removed.
+
+`);
+}
+async function hooksStatus(projectRoot) {
+  const settings = readInstalledHooks(projectRoot);
+  const hooks = settings.hooks ?? {};
+  const entries = Object.entries(hooks).flatMap(
+    ([event, arr]) => arr.map((e) => ({ event, ...e }))
+  );
+  if (entries.length === 0) {
+    process.stdout.write('\n  No hooks installed. Run "claudectx hooks add <name>" to add one.\n\n');
+    return;
+  }
+  process.stdout.write("\n  Installed hooks:\n");
+  for (const entry of entries) {
+    const name = entry.name ?? "unnamed";
+    const event = entry.event;
+    const matcher = entry.matcher ? ` / ${entry.matcher}` : "";
+    process.stdout.write(`    ${name.padEnd(18)} ${event}${matcher}
+`);
+  }
+  process.stdout.write("\n");
+}
+async function hooksCommand(subcommand, options) {
+  const projectPath = options.path ? path25.resolve(options.path) : process.cwd();
+  const projectRoot = findProjectRoot(projectPath) ?? projectPath;
+  const sub = subcommand ?? "list";
+  switch (sub) {
+    case "list":
+      await hooksList(projectRoot);
+      break;
+    case "add": {
+      const name = options.name;
+      if (!name) {
+        process.stderr.write("Usage: claudectx hooks add <name> [--config key=value]\n");
+        process.exit(1);
+      }
+      await hooksAdd(name, projectRoot, options.config ?? []);
+      break;
+    }
+    case "remove": {
+      const name = options.name;
+      if (!name) {
+        process.stderr.write("Usage: claudectx hooks remove <name>\n");
+        process.exit(1);
+      }
+      await hooksRemove(name, projectRoot);
+      break;
+    }
+    case "status":
+      await hooksStatus(projectRoot);
+      break;
+    default:
+      process.stderr.write(
+        `Unknown sub-command "${sub}". Use: list | add <name> | remove <name> | status
+`
+      );
+      process.exit(1);
+  }
+}
+
+// src/commands/convert.ts
+init_esm_shims();
+import * as fs22 from "fs";
+import * as path26 from "path";
+function slugify2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function claudeMdToCursorRules(content) {
+  const files = [];
+  const lines = content.split("\n");
+  let currentHeader = "";
+  let currentBody = [];
+  function flushSection() {
+    if (!currentHeader) return;
+    const slug = slugify2(currentHeader);
+    if (!slug) return;
+    const mdc = [
+      "---",
+      `description: ${currentHeader}`,
+      "alwaysApply: true",
+      "---",
+      "",
+      ...currentBody
+    ].join("\n");
+    files.push({ filename: `${slug}.mdc`, content: mdc });
+  }
+  for (const line of lines) {
+    const match = line.match(/^##\s+(.+)$/);
+    if (match) {
+      flushSection();
+      currentHeader = match[1];
+      currentBody = [];
+    } else if (currentHeader) {
+      currentBody.push(line);
+    }
+  }
+  flushSection();
+  if (files.length === 0 && content.trim()) {
+    files.push({
+      filename: "project-instructions.mdc",
+      content: ["---", "description: Project Instructions", "alwaysApply: true", "---", "", content].join("\n")
+    });
+  }
+  return files;
+}
+function claudeMdToCopilot(content) {
+  return content.split("\n").filter((line) => !line.match(/^@.+$/)).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function claudeMdToWindsurf(content) {
+  return content.split("\n").filter((line) => !line.match(/^@.+$/)).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function convertCommand(options) {
+  const projectPath = options.path ? path26.resolve(options.path) : process.cwd();
+  const projectRoot = findProjectRoot(projectPath) ?? projectPath;
+  const from = options.from ?? "claude";
+  const to = options.to;
+  if (from !== "claude") {
+    process.stderr.write(`Error: --from "${from}" is not yet supported. Only --from claude is available.
+`);
+    process.exit(1);
+  }
+  const claudeMdPath = path26.join(projectRoot, "CLAUDE.md");
+  let content = "";
+  try {
+    content = fs22.readFileSync(claudeMdPath, "utf-8");
+  } catch {
+    process.stderr.write(`Error: CLAUDE.md not found at ${claudeMdPath}
+`);
+    process.exit(1);
+  }
+  if (to === "cursor") {
+    const files = claudeMdToCursorRules(content);
+    const targetDir = path26.join(projectRoot, ".cursor", "rules");
+    process.stdout.write(`
+Converting CLAUDE.md \u2192 ${files.length} Cursor rule file(s)
+
+`);
+    for (const file of files) {
+      const filePath = path26.join(targetDir, file.filename);
+      process.stdout.write(`  ${options.dryRun ? "[dry-run] " : ""}\u2192 .cursor/rules/${file.filename}
+`);
+      if (!options.dryRun) {
+        fs22.mkdirSync(targetDir, { recursive: true });
+        fs22.writeFileSync(filePath, file.content, "utf-8");
+      }
+    }
+    process.stdout.write("\n");
+  } else if (to === "copilot") {
+    const converted = claudeMdToCopilot(content);
+    const targetPath = path26.join(projectRoot, ".github", "copilot-instructions.md");
+    process.stdout.write(`
+Converting CLAUDE.md \u2192 .github/copilot-instructions.md
+`);
+    if (!options.dryRun) {
+      fs22.mkdirSync(path26.dirname(targetPath), { recursive: true });
+      fs22.writeFileSync(targetPath, converted, "utf-8");
+      process.stdout.write(`  \u2713 Written to ${targetPath}
+
+`);
+    } else {
+      process.stdout.write(`  [dry-run] Would write ${converted.length} chars to ${targetPath}
+
+`);
+    }
+  } else if (to === "windsurf") {
+    const converted = claudeMdToWindsurf(content);
+    const targetPath = path26.join(projectRoot, ".windsurfrules");
+    process.stdout.write(`
+Converting CLAUDE.md \u2192 .windsurfrules
+`);
+    if (!options.dryRun) {
+      fs22.writeFileSync(targetPath, converted, "utf-8");
+      process.stdout.write(`  \u2713 Written to ${targetPath}
+
+`);
+    } else {
+      process.stdout.write(`  [dry-run] Would write ${converted.length} chars to ${targetPath}
+
+`);
+    }
+  } else {
+    process.stderr.write(`Error: unknown target "${to}". Use: cursor | copilot | windsurf
+`);
+    process.exit(1);
+  }
+}
+
+// src/commands/teams.ts
+init_esm_shims();
+init_models();
+import * as path28 from "path";
+import * as fs24 from "fs";
+
+// src/reporter/team-aggregator.ts
+init_esm_shims();
+init_session_reader();
+init_session_store();
+init_models();
+import * as fs23 from "fs";
+import * as path27 from "path";
+import * as os4 from "os";
+import * as childProcess2 from "child_process";
+function getDeveloperIdentity() {
+  try {
+    const email = childProcess2.execSync("git config user.email", { encoding: "utf-8", timeout: 2e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (email) return email;
+  } catch {
+  }
+  return os4.hostname();
+}
+function calcCost3(inputTokens, outputTokens, model) {
+  const p = MODEL_PRICING[model];
+  return inputTokens / 1e6 * p.inputPerMillion + outputTokens / 1e6 * p.outputPerMillion;
+}
+function isoDate2(d) {
+  return d.toISOString().slice(0, 10);
+}
+function anonymizeExport(report, index) {
+  return {
+    ...report,
+    developer: {
+      ...report.developer,
+      identity: `Dev ${index + 1}`
+    }
+  };
+}
+async function buildTeamExport(days, model, anonymize) {
+  const now = /* @__PURE__ */ new Date();
+  const cutoff = new Date(now);
+  cutoff.setDate(cutoff.getDate() - days);
+  const cutoffMs = cutoff.getTime();
+  const sessionFiles = listSessionFiles().filter((f) => f.mtimeMs >= cutoffMs);
+  const bucketMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < days; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    const dateStr = isoDate2(d);
+    bucketMap.set(dateStr, {
+      date: dateStr,
+      sessions: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      requests: 0,
+      costUsd: 0
+    });
+  }
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCacheRead = 0;
+  let totalRequests = 0;
+  for (const sf of sessionFiles) {
+    const dateStr = isoDate2(new Date(sf.mtimeMs));
+    const bucket = bucketMap.get(dateStr);
+    const usage = readSessionUsage(sf.filePath);
+    if (bucket) {
+      bucket.sessions++;
+      bucket.inputTokens += usage.inputTokens;
+      bucket.outputTokens += usage.outputTokens;
+      bucket.cacheReadTokens += usage.cacheReadTokens;
+      bucket.requests += usage.requestCount;
+      bucket.costUsd += calcCost3(usage.inputTokens, usage.outputTokens, model);
+    }
+    totalInput += usage.inputTokens;
+    totalOutput += usage.outputTokens;
+    totalCacheRead += usage.cacheReadTokens;
+    totalRequests += usage.requestCount;
+  }
+  const fileEvents = readAllEvents().filter(
+    (e) => new Date(e.timestamp).getTime() >= cutoffMs
+  );
+  const topWasteFiles = aggregateStats(fileEvents).slice(0, 10).map((s) => ({ filePath: s.filePath, readCount: s.readCount }));
+  const totalCostUsd = calcCost3(totalInput, totalOutput, model);
+  const cacheHitRate = totalInput > 0 ? Math.round(totalCacheRead / totalInput * 100) : 0;
+  const uniqueSessions = new Set(sessionFiles.map((f) => f.sessionId)).size;
+  const developer = {
+    identity: getDeveloperIdentity(),
+    exportedAt: now.toISOString(),
+    periodDays: days,
+    totalCostUsd,
+    totalInputTokens: totalInput,
+    totalOutputTokens: totalOutput,
+    cacheHitRate,
+    avgRequestSize: totalRequests > 0 ? Math.round(totalInput / totalRequests) : 0,
+    topWasteFiles,
+    sessionCount: uniqueSessions
+  };
+  const byDay = [...bucketMap.values()].sort((a, b) => a.date.localeCompare(b.date));
+  const exportData = { version: "1", developer, byDay };
+  if (anonymize) return anonymizeExport(exportData, 0);
+  return exportData;
+}
+function aggregateTeamReports(exports) {
+  const developers = exports.map((e) => e.developer);
+  developers.sort((a, b) => b.totalCostUsd - a.totalCostUsd);
+  const teamTotalCostUsd = developers.reduce((sum, d) => sum + d.totalCostUsd, 0);
+  const teamCacheHitRate = developers.length > 0 ? Math.round(developers.reduce((sum, d) => sum + d.cacheHitRate, 0) / developers.length) : 0;
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const dev of developers) {
+    for (const wf of dev.topWasteFiles) {
+      const existing = fileMap.get(wf.filePath);
+      if (existing) {
+        existing.readCount += wf.readCount;
+        existing.developers.push(dev.identity);
+      } else {
+        fileMap.set(wf.filePath, { readCount: wf.readCount, developers: [dev.identity] });
+      }
+    }
+  }
+  const topWasteFiles = [...fileMap.entries()].map(([filePath, data]) => ({ filePath, ...data })).sort((a, b) => b.readCount - a.readCount).slice(0, 10);
+  const periodDays = exports[0]?.developer.periodDays ?? 30;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalDevelopers: exports.length,
+    periodDays,
+    developers,
+    teamTotalCostUsd,
+    teamCacheHitRate,
+    topWasteFiles
+  };
+}
+function writeTeamExport(exportData) {
+  const storeDir = getStoreDir();
+  if (!fs23.existsSync(storeDir)) fs23.mkdirSync(storeDir, { recursive: true });
+  const date = isoDate2(/* @__PURE__ */ new Date());
+  const filePath = path27.join(storeDir, `team-export-${date}.json`);
+  fs23.writeFileSync(filePath, JSON.stringify(exportData, null, 2), "utf-8");
+  return filePath;
+}
+function readTeamExports(dir) {
+  const exports = [];
+  if (!fs23.existsSync(dir)) return exports;
+  const files = fs23.readdirSync(dir).filter((f) => f.match(/^team-export-.*\.json$/));
+  for (const file of files) {
+    try {
+      const raw = fs23.readFileSync(path27.join(dir, file), "utf-8");
+      exports.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return exports;
+}
+
+// src/commands/teams.ts
+init_session_store();
+async function teamsExport(options) {
+  const model = resolveModel(options.model ?? "sonnet");
+  const days = parseInt(options.days ?? "30", 10);
+  const anonymize = options.anonymize ?? false;
+  const exportData = await buildTeamExport(days, model, anonymize);
+  if (options.json) {
+    process.stdout.write(JSON.stringify(exportData, null, 2) + "\n");
+    return;
+  }
+  const filePath = writeTeamExport(exportData);
+  process.stdout.write("\n");
+  process.stdout.write(`claudectx teams export
+`);
+  process.stdout.write("\u2550".repeat(45) + "\n");
+  process.stdout.write(`  Developer:    ${exportData.developer.identity}
+`);
+  process.stdout.write(`  Period:       Last ${days} days
+`);
+  process.stdout.write(`  Sessions:     ${exportData.developer.sessionCount}
+`);
+  process.stdout.write(`  Total cost:   ${formatCost(exportData.developer.totalCostUsd)}
+`);
+  process.stdout.write(`  Cache rate:   ${exportData.developer.cacheHitRate}%
+`);
+  process.stdout.write(`
+  \u2713 Saved to: ${filePath}
+`);
+  process.stdout.write("  Share this file with your team lead for aggregation.\n\n");
+}
+async function teamsAggregate(options) {
+  const dir = options.dir ?? getStoreDir();
+  const anonymize = options.anonymize ?? false;
+  const exports = readTeamExports(dir);
+  if (exports.length === 0) {
+    process.stderr.write(
+      `No team export files found in ${dir}.
+Run "claudectx teams export" on each developer machine first.
+`
+    );
+    process.exit(1);
+  }
+  const anonymized = anonymize ? exports.map((e, i) => anonymizeExport(e, i)) : exports;
+  const report = aggregateTeamReports(anonymized);
+  if (options.json) {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write("\n");
+  process.stdout.write("claudectx teams aggregate \u2014 team cost report\n");
+  process.stdout.write("\u2550".repeat(55) + "\n");
+  process.stdout.write(`  Developers:       ${report.totalDevelopers}
+`);
+  process.stdout.write(`  Period:           Last ${report.periodDays} days
+`);
+  process.stdout.write(`  Team total cost:  ${formatCost(report.teamTotalCostUsd)}
+`);
+  process.stdout.write(`  Team cache rate:  ${report.teamCacheHitRate}%
+`);
+  process.stdout.write("\n");
+  process.stdout.write(
+    `  ${"Developer".padEnd(30)}  ${"Cost".padStart(8)}  ${"Cache".padStart(6)}  Sessions
+`
+  );
+  process.stdout.write("\u2500".repeat(55) + "\n");
+  for (const dev of report.developers) {
+    const identity = dev.identity.slice(0, 30).padEnd(30);
+    const cost = formatCost(dev.totalCostUsd).padStart(8);
+    const cache = `${dev.cacheHitRate}%`.padStart(6);
+    const sessions = String(dev.sessionCount).padStart(8);
+    process.stdout.write(`  ${identity}  ${cost}  ${cache}  ${sessions}
+`);
+  }
+  process.stdout.write("\n");
+  if (report.topWasteFiles.length > 0) {
+    process.stdout.write("  Top shared files (by read count across team):\n");
+    for (const f of report.topWasteFiles.slice(0, 5)) {
+      const devList = f.developers.slice(0, 3).join(", ");
+      process.stdout.write(`    ${f.readCount}x  ${path28.basename(f.filePath)}  (${devList})
+`);
+    }
+    process.stdout.write("\n");
+  }
+}
+async function teamsShare(options) {
+  const dest = options.to;
+  if (!dest) {
+    process.stderr.write("Usage: claudectx teams share --to <path>\n");
+    process.exit(1);
+  }
+  const storeDir = getStoreDir();
+  const exportFiles = fs24.readdirSync(storeDir).filter((f) => f.match(/^team-export-.*\.json$/)).sort().reverse();
+  if (exportFiles.length === 0) {
+    process.stderr.write('No team export files found. Run "claudectx teams export" first.\n');
+    process.exit(1);
+  }
+  const latest = exportFiles[0];
+  const src = path28.join(storeDir, latest);
+  const destPath = fs24.statSync(dest).isDirectory() ? path28.join(dest, latest) : dest;
+  fs24.copyFileSync(src, destPath);
+  process.stdout.write(`  \u2713 Copied ${latest} \u2192 ${destPath}
+
+`);
+}
+async function teamsCommand(subcommand, options) {
+  switch (subcommand) {
+    case "export":
+      await teamsExport(options);
+      break;
+    case "aggregate":
+      await teamsAggregate(options);
+      break;
+    case "share":
+      await teamsShare(options);
+      break;
+    default:
+      process.stderr.write(
+        `Unknown sub-command "${subcommand}". Use: export | aggregate | share
+`
+      );
+      process.exit(1);
+  }
+}
+
 // src/index.ts
 var VERSION = "1.0.0";
 var DESCRIPTION = "Reduce Claude Code token usage by up to 80%. Context analyzer, auto-optimizer, live dashboard, and smart MCP tools.";
@@ -3004,5 +4282,23 @@ program.command("compress").alias("c").description("Compress a Claude Code sessi
 program.command("report").alias("r").description("Show token usage analytics for the last N days").option("-p, --path <path>", "Project directory (default: cwd)").option("--days <n>", "Number of days to include", "7").option("--json", "Machine-readable JSON output").option("--markdown", "GitHub-flavoured Markdown output").option("-m, --model <model>", "Claude model for cost estimates (haiku|sonnet|opus)", "sonnet").action(async (options) => {
   await reportCommand(options);
 });
+program.command("budget <globs...>").description("Estimate token cost before running a task").option("-m, --model <model>", "Model for cost estimates (haiku|sonnet|opus)", "sonnet").option("--threshold <n>", "Warn if total exceeds N tokens", "10000").option("-p, --path <path>", "Project directory").option("--json", "JSON output").action(async (globs, options) => {
+  await budgetCommand(globs, options);
+});
+program.command("warmup").description("Pre-warm the Anthropic prompt cache with your CLAUDE.md").option("-m, --model <model>", "Model (haiku|sonnet|opus)", "haiku").option("--ttl <minutes>", "Cache TTL: 5 or 60", "5").option("--cron <expr>", 'Install as cron job (e.g. "0 9 * * 1-5")').option("--api-key <key>", "Anthropic API key").option("-p, --path <path>", "Project directory").option("--json", "JSON output").action(async (options) => {
+  await warmupCommand(options);
+});
+program.command("drift").description("Detect stale references and dead sections in CLAUDE.md").option("-p, --path <path>", "Project directory").option("--days <n>", "Days window for section usage", "30").option("--fix", "Interactively remove flagged lines").option("--json", "JSON output").action(async (options) => {
+  await driftCommand(options);
+});
+program.command("hooks [subcommand] [name]").description("Hook marketplace: list | add <name> | remove <name> | status").option("-p, --path <path>", "Project directory").option("--config <pair...>", "key=value config pairs for add").action(async (subcommand, name, options) => {
+  await hooksCommand(subcommand, { ...options, name });
+});
+program.command("convert").description("Convert CLAUDE.md to another AI assistant format").option("--from <assistant>", "Source format (default: claude)", "claude").requiredOption("--to <assistant>", "Target format: cursor | copilot | windsurf").option("--dry-run", "Preview without writing").option("-p, --path <path>", "Project directory").action(async (options) => {
+  await convertCommand(options);
+});
+program.command("teams [subcommand]").description("Multi-developer cost attribution (export | aggregate | share)").option("--days <n>", "Days to include", "30").option("-m, --model <model>", "Model", "sonnet").option("--anonymize", "Replace identities with Dev 1, Dev 2...").option("--dir <path>", "Directory with team export JSON files").option("--to <path>", "Destination for share sub-command").option("--json", "JSON output").action(async (subcommand, options) => {
+  await teamsCommand(subcommand ?? "export", options);
+});
 program.parse();
 //# sourceMappingURL=index.mjs.map