fathom-cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,10 +1,39 @@
 #!/usr/bin/env node
-import {
-  __commonJS,
-  __export,
-  __require,
-  __toESM
-} from "./chunk-SEGVTWSK.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // ../../node_modules/.pnpm/extend@3.0.2/node_modules/extend/index.js
 var require_extend = __commonJS({
@@ -98,7 +127,7 @@ var require_extend = __commonJS({
 });
 
 // src/index.ts
-import { Command as Command13 } from "commander";
+import { Command as Command15 } from "commander";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -5141,7 +5170,7 @@ var Processor = class _Processor extends CallableInstance {
     assertParser("process", this.parser || this.Parser);
     assertCompiler("process", this.compiler || this.Compiler);
     return done ? executor(void 0, done) : new Promise(executor);
-    function executor(resolve12, reject) {
+    function executor(resolve14, reject) {
       const realFile = vfile(file);
       const parseTree = (
         /** @type {HeadTree extends undefined ? Node : HeadTree} */
@@ -5172,8 +5201,8 @@ var Processor = class _Processor extends CallableInstance {
       function realDone(error, file2) {
         if (error || !file2) {
           reject(error);
-        } else if (resolve12) {
-          resolve12(file2);
+        } else if (resolve14) {
+          resolve14(file2);
         } else {
           ok(done, "`done` is defined if `resolve` is not");
           done(void 0, file2);
@@ -5275,7 +5304,7 @@ var Processor = class _Processor extends CallableInstance {
       file = void 0;
     }
     return done ? executor(void 0, done) : new Promise(executor);
-    function executor(resolve12, reject) {
+    function executor(resolve14, reject) {
       ok(
         typeof file !== "function",
         "`file` can\u2019t be a `done` anymore, we checked"
@@ -5289,8 +5318,8 @@ var Processor = class _Processor extends CallableInstance {
         );
         if (error) {
           reject(error);
-        } else if (resolve12) {
-          resolve12(resultingTree);
+        } else if (resolve14) {
+          resolve14(resultingTree);
         } else {
           ok(done, "`done` is defined if `resolve` is not");
           done(void 0, resultingTree, file2);
@@ -8118,10 +8147,10 @@ function resolveAll(constructs2, events, context) {
   const called = [];
   let index2 = -1;
   while (++index2 < constructs2.length) {
-    const resolve12 = constructs2[index2].resolveAll;
-    if (resolve12 && !called.includes(resolve12)) {
-      events = resolve12(events, context);
-      called.push(resolve12);
+    const resolve14 = constructs2[index2].resolveAll;
+    if (resolve14 && !called.includes(resolve14)) {
+      events = resolve14(events, context);
+      called.push(resolve14);
     }
   }
   return events;
@@ -15638,6 +15667,62 @@ function generateRegistry(project, features, estimates) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+async function getAnthropicClient(apiKey) {
+  const { default: AnthropicSDK } = await import("@anthropic-ai/sdk");
+  return new AnthropicSDK({ apiKey: apiKey ?? process.env.ANTHROPIC_API_KEY });
+}
+var AIComplexityResult = external_exports.object({
+  complexity: Complexity,
+  taskTypes: external_exports.array(TaskType),
+  dependencies: external_exports.array(external_exports.string()),
+  aiTasks: external_exports.array(external_exports.string()),
+  rationale: external_exports.string()
+});
+var TASK_TYPE_VALUES = TaskType.options.join(", ");
+var SYSTEM_PROMPT = `You are a technical complexity scorer for software features. Given a feature description, analyze it and return a JSON object with:
+
+- complexity: One of "S", "M", "L", "XL"
+  - S: Single file, simple change, <30 min
+  - M: 2-5 files, typical feature, 1-3 hours
+  - L: 5-15 files, multiple integrations, 3-8 hours
+  - XL: 15+ files, system-wide changes, 8+ hours
+- taskTypes: Array of applicable task types from: ${TASK_TYPE_VALUES}
+- dependencies: Array of likely external dependencies or integrations (e.g., "OAuth provider", "database migration")
+- aiTasks: Array of 2-5 discrete AI coding tasks (e.g., "scaffold-auth-flow", "write-api-tests")
+- rationale: One sentence explaining the complexity assessment
+
+Respond with ONLY a JSON object. No markdown, no explanation.`;
+async function scoreComplexityAI(description, options = {}) {
+  try {
+    const client = options.client ?? await getAnthropicClient(options.apiKey);
+    const model = options.model ?? "claude-haiku-4-5-20251001";
+    const response = await client.messages.create({
+      model,
+      max_tokens: 1024,
+      system: SYSTEM_PROMPT,
+      messages: [
+        {
+          role: "user",
+          content: `Analyze the complexity of this feature:
+
+${description}`
+        }
+      ]
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    if (!textBlock || textBlock.type !== "text") {
+      return null;
+    }
+    let jsonText = textBlock.text.trim();
+    if (jsonText.startsWith("```")) {
+      jsonText = jsonText.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    const parsed = JSON.parse(jsonText);
+    return AIComplexityResult.parse(parsed);
+  } catch {
+    return null;
+  }
+}
 var VERSION = "0.1.0";
 
 // src/commands/analyze.ts
@@ -16957,8 +17042,8 @@ Calibration summary (${drifts.length} features with data):`));
 // src/commands/estimate.ts
 import { Command as Command8 } from "commander";
 import chalk9 from "chalk";
-var estimateCommand = new Command8("estimate").description("Quick single-feature estimate from a description").argument("<description>", "Feature description").option("-c, --complexity <size>", "Override complexity (S/M/L/XL)").option("--category <cat>", "Feature category", "general").action(
-  (description, options) => {
+var estimateCommand = new Command8("estimate").description("Quick single-feature estimate from a description").argument("<description>", "Feature description").option("-c, --complexity <size>", "Override complexity (S/M/L/XL)").option("--category <cat>", "Feature category", "general").option("--no-ai", "Skip AI complexity scoring, use heuristic only").action(
+  async (description, options) => {
     const data = loadData();
     const feature = {
       id: "quick-estimate",
@@ -16969,7 +17054,27 @@ var estimateCommand = new Command8("estimate").description("Quick single-feature
       dependencies: [],
       aiTasks: []
     };
-    if (!options.complexity) {
+    let complexitySource = "heuristic";
+    let rationale;
+    if (options.complexity) {
+      complexitySource = "manual";
+    } else if (options.ai !== false) {
+      const aiResult = await scoreComplexityAI(description);
+      if (aiResult) {
+        feature.complexity = aiResult.complexity;
+        feature.dependencies = aiResult.dependencies;
+        feature.aiTasks = aiResult.aiTasks;
+        complexitySource = "AI";
+        rationale = aiResult.rationale;
+      } else {
+        feature.complexity = scoreComplexity(feature);
+        console.log(
+          chalk9.dim(
+            "  (AI scoring unavailable \u2014 using heuristic. Set ANTHROPIC_API_KEY for richer estimates)\n"
+          )
+        );
+      }
+    } else {
       feature.complexity = scoreComplexity(feature);
     }
     const taskTypes = mapTaskTypes(feature);
@@ -16978,7 +17083,12 @@ var estimateCommand = new Command8("estimate").description("Quick single-feature
     console.log(chalk9.bold("\nFathom \u2014 Quick Estimate"));
     console.log(chalk9.dim("\u2500".repeat(50)));
     console.log(`  Feature:    ${feature.name}`);
-    console.log(`  Complexity: ${feature.complexity}`);
+    console.log(
+      `  Complexity: ${feature.complexity} ${chalk9.dim(`(${complexitySource})`)}`
+    );
+    if (rationale) {
+      console.log(`  Rationale:  ${chalk9.dim(rationale)}`);
+    }
     console.log(`  Tasks:      ${taskTypes.join(", ")}`);
     console.log(`  Model:      ${rec.model} (${rec.reason})`);
     console.log(chalk9.dim("\u2500".repeat(50)));
@@ -17603,8 +17713,8 @@ var IntakeResult = external_exports.object({
   totalEstimatedCost: external_exports.number(),
   createdAt: external_exports.string()
 });
-async function getAnthropicClient(apiKey) {
-  const { default: AnthropicSDK } = await import("./sdk-OEGEIPVM.js");
+async function getAnthropicClient2(apiKey) {
+  const { default: AnthropicSDK } = await import("@anthropic-ai/sdk");
   return new AnthropicSDK({ apiKey: apiKey ?? process.env.ANTHROPIC_API_KEY });
 }
 var EXTRACTION_SYSTEM_PROMPT = `You are a technical project analyst. Your job is to extract discrete, actionable work items from raw input (user feedback, bug reports, meeting notes, design handoffs, etc.).
@@ -17624,8 +17734,8 @@ Split compound requests into separate items. Identify implicit requirements. Be
 Respond with ONLY a JSON array of items. No markdown, no explanation.`;
 var ExtractionResponse = external_exports.array(ExtractedItem);
 async function extractWorkItems(rawInput, options = {}) {
-  const client = options.client ?? await getAnthropicClient(options.apiKey);
-  const model = options.model ?? "claude-sonnet-4-6-20250514";
+  const client = options.client ?? await getAnthropicClient2(options.apiKey);
+  const model = options.model ?? "claude-sonnet-4-20250514";
   const response = await client.messages.create({
     model,
     max_tokens: 4096,
@@ -17941,8 +18051,535 @@ var initCommand = new Command12("init").description("Initialize Fathom global co
   );
 });
 
+// src/commands/rename.ts
+import { Command as Command13 } from "commander";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync5, existsSync as existsSync12 } from "fs";
+import { resolve as resolve12 } from "path";
+import chalk14 from "chalk";
+var renameCommand = new Command13("rename").description("Rename the project in all .claude/te/ config files").argument("<name>", "New project name").action((name) => {
+  const baseDir = process.cwd();
+  const teDir = resolve12(baseDir, ".claude", "te");
+  if (!existsSync12(teDir)) {
+    console.error(
+      chalk14.red("\n  Error: .claude/te/ not found. Run `fathom setup` first.\n")
+    );
+    process.exit(1);
+  }
+  const jsonFiles = [
+    resolve12(teDir, "config.json"),
+    resolve12(teDir, "registry.json"),
+    resolve12(teDir, "tracking", "summary.json")
+  ];
+  let oldName = "unnamed";
+  let updated = 0;
+  for (const filePath of jsonFiles) {
+    if (!existsSync12(filePath)) continue;
+    const data = JSON.parse(readFileSync12(filePath, "utf-8"));
+    if (data.project) {
+      oldName = data.project;
+      data.project = name;
+      writeFileSync5(filePath, JSON.stringify(data, null, 2) + "\n");
+      updated++;
+    }
+  }
+  const skillPath = resolve12(baseDir, ".claude", "skills", "fathom", "SKILL.md");
+  if (existsSync12(skillPath)) {
+    const content3 = readFileSync12(skillPath, "utf-8");
+    const newContent = content3.replaceAll(oldName, name);
+    if (newContent !== content3) {
+      writeFileSync5(skillPath, newContent);
+      updated++;
+    }
+  }
+  const hookPath = resolve12(baseDir, ".claude", "hooks", "te-session-sync.sh");
+  if (existsSync12(hookPath)) {
+    const content3 = readFileSync12(hookPath, "utf-8");
+    const newContent = content3.replaceAll(oldName, name);
+    if (newContent !== content3) {
+      writeFileSync5(hookPath, newContent);
+      updated++;
+    }
+  }
+  console.log(
+    chalk14.bold(`
+  Renamed "${oldName}" \u2192 "${name}" (${updated} files updated)
+`)
+  );
+});
+
+// src/commands/research.ts
+import { Command as Command14 } from "commander";
+import { writeFileSync as writeFileSync6, existsSync as existsSync13 } from "fs";
+import { resolve as resolve13 } from "path";
+import chalk15 from "chalk";
+
+// src/fetchers/types.ts
+var RemoteManifest = external_exports.object({
+  version: external_exports.number(),
+  updated: external_exports.string(),
+  models: external_exports.array(ModelPricing),
+  recommendations: external_exports.record(external_exports.string(), AgentRecommendation)
+});
+var IntelligenceSuggestion = external_exports.object({
+  type: external_exports.enum(["new-model", "price-change", "recommendation-change", "deprecation", "general"]),
+  model: external_exports.string().optional(),
+  description: external_exports.string(),
+  confidence: external_exports.enum(["high", "medium", "low"])
+});
+var IntelligenceResponse = external_exports.object({
+  suggestions: external_exports.array(IntelligenceSuggestion),
+  summary: external_exports.string()
+});
+
+// src/fetchers/pricing-fetcher.ts
+var MANIFEST_URL = "https://raw.githubusercontent.com/anthropics/fathom/main/data/remote-manifest.json";
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function fetchPricing(options = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (options.offline) {
+    return loadLocalPricing(now);
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+    );
+    if (options.verbose) {
+      console.log(`  Fetching: ${MANIFEST_URL}`);
+    }
+    const response = await fetch(MANIFEST_URL, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const json2 = await response.json();
+    const manifest = RemoteManifest.parse(json2);
+    return {
+      data: {
+        models: manifest.models,
+        recommendations: manifest.recommendations,
+        manifestVersion: manifest.version,
+        manifestDate: manifest.updated
+      },
+      source: "remote",
+      stale: false,
+      fetchedAt: now
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    if (options.verbose) {
+      console.log(`  Remote fetch failed: ${errorMsg}`);
+    }
+    return loadLocalPricing(now, errorMsg);
+  }
+}
+function loadLocalPricing(fetchedAt, error) {
+  const data = loadData();
+  return {
+    data: {
+      models: data.models,
+      recommendations: data.recommendations,
+      manifestVersion: 0,
+      manifestDate: "local"
+    },
+    source: "local",
+    stale: true,
+    fetchedAt,
+    error: error ?? "offline mode"
+  };
+}
+
+// src/fetchers/intelligence-fetcher.ts
+async function getAnthropicClient3(apiKey) {
+  const { default: AnthropicSDK } = await import("@anthropic-ai/sdk");
+  return new AnthropicSDK({ apiKey: apiKey ?? process.env.ANTHROPIC_API_KEY });
+}
+var SYSTEM_PROMPT2 = `You are an AI model pricing analyst. Given the current model pricing and agent recommendations for an AI development workflow tool, review them and suggest updates.
+
+You should:
+1. Flag any models with outdated pricing based on your knowledge
+2. Suggest new models that should be added (only well-established models from major providers)
+3. Flag any recommendation changes (e.g., if a newer model is better suited for a task category)
+4. Note any models that may be deprecated or renamed
+
+Respond with ONLY valid JSON matching this schema:
+{
+  "suggestions": [
+    {
+      "type": "new-model" | "price-change" | "recommendation-change" | "deprecation" | "general",
+      "model": "model-id (optional)",
+      "description": "what changed or should change",
+      "confidence": "high" | "medium" | "low"
+    }
+  ],
+  "summary": "one sentence overall assessment"
+}
+
+If everything looks current, return an empty suggestions array with a summary saying so.`;
+async function fetchIntelligence(models, recommendations, options = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
+  if (options.offline || !apiKey) {
+    if (options.verbose) {
+      console.log(
+        apiKey ? "  Intelligence: skipped (offline mode)" : "  Intelligence: skipped (no ANTHROPIC_API_KEY)"
+      );
+    }
+    return null;
+  }
+  try {
+    if (options.verbose) {
+      console.log("  Intelligence: querying Claude Haiku...");
+    }
+    const client = await getAnthropicClient3(apiKey);
+    const modelsDesc = models.map((m) => `${m.id} (${m.name}): $${m.input_per_mtok}/$${m.output_per_mtok} per MTok, tier=${m.tier}`).join("\n");
+    const recsDesc = Object.entries(recommendations).map(([cat, rec]) => `${cat}: ${rec.model} \u2014 ${rec.reason}`).join("\n");
+    const userPrompt = `Current model pricing:
+${modelsDesc}
+
+Current agent recommendations:
+${recsDesc}`;
+    const response = await client.messages.create({
+      model: "claude-haiku-4-5-20251001",
+      max_tokens: 1024,
+      system: SYSTEM_PROMPT2,
+      messages: [{ role: "user", content: userPrompt }]
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    if (!textBlock || textBlock.type !== "text") {
+      throw new Error("No text content in response");
+    }
+    let jsonText = textBlock.text.trim();
+    if (jsonText.startsWith("```")) {
+      jsonText = jsonText.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    const parsed = JSON.parse(jsonText);
+    const intelligence = IntelligenceResponse.parse(parsed);
+    return {
+      data: intelligence,
+      source: "api",
+      stale: false,
+      fetchedAt: now
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    if (options.verbose) {
+      console.log(`  Intelligence fetch failed: ${errorMsg}`);
+    }
+    return null;
+  }
+}
+
+// src/fetchers/merge.ts
+function mergePricingData(localModels, remoteModels, localRecs, remoteRecs, suggestions = []) {
+  const mergedModels = [];
+  const modelChanges = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const remote of remoteModels) {
+    seenIds.add(remote.id);
+    const local = localModels.find((m) => m.id === remote.id);
+    if (!local) {
+      mergedModels.push(remote);
+      modelChanges.push({ id: remote.id, name: remote.name, status: "added" });
+      continue;
+    }
+    const fields = [];
+    const pricingKeys = [
+      "input_per_mtok",
+      "output_per_mtok",
+      "cache_read_per_mtok",
+      "batch_discount"
+    ];
+    for (const key of pricingKeys) {
+      if (local[key] !== remote[key]) {
+        fields.push({ field: key, old: local[key], new: remote[key] });
+      }
+    }
+    if (local.tier !== remote.tier) {
+      fields.push({ field: "tier", old: local.tier, new: remote.tier });
+    }
+    mergedModels.push(remote);
+    modelChanges.push({
+      id: remote.id,
+      name: remote.name,
+      status: fields.length > 0 ? "updated" : "unchanged",
+      fields: fields.length > 0 ? fields : void 0
+    });
+  }
+  for (const local of localModels) {
+    if (!seenIds.has(local.id)) {
+      mergedModels.push(local);
+      modelChanges.push({ id: local.id, name: local.name, status: "unchanged" });
+    }
+  }
+  const mergedRecs = { ...localRecs };
+  const recChanges = [];
+  for (const [cat, remoteRec] of Object.entries(remoteRecs)) {
+    const localRec = localRecs[cat];
+    if (!localRec) {
+      mergedRecs[cat] = remoteRec;
+      recChanges.push({
+        category: cat,
+        status: "added",
+        newModel: remoteRec.model,
+        reason: remoteRec.reason
+      });
+    } else if (localRec.model !== remoteRec.model || localRec.reason !== remoteRec.reason) {
+      mergedRecs[cat] = remoteRec;
+      recChanges.push({
+        category: cat,
+        status: "updated",
+        oldModel: localRec.model,
+        newModel: remoteRec.model,
+        reason: remoteRec.reason
+      });
+    } else {
+      recChanges.push({ category: cat, status: "unchanged" });
+    }
+  }
+  return {
+    models: {
+      merged: mergedModels,
+      changes: modelChanges,
+      added: modelChanges.filter((c) => c.status === "added").length,
+      updated: modelChanges.filter((c) => c.status === "updated").length,
+      unchanged: modelChanges.filter((c) => c.status === "unchanged").length
+    },
+    recommendations: {
+      merged: mergedRecs,
+      changes: recChanges,
+      added: recChanges.filter((c) => c.status === "added").length,
+      updated: recChanges.filter((c) => c.status === "updated").length,
+      unchanged: recChanges.filter((c) => c.status === "unchanged").length
+    },
+    suggestions
+  };
+}
+function generateModelsYaml(models) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  let yaml = `# Model pricing registry \u2014 updated via \`fathom research\`
+`;
+  yaml += `# Last verified: ${date}
+
+`;
+  yaml += `models:
+`;
+  for (const m of models) {
+    yaml += `  - id: ${m.id}
+`;
+    yaml += `    provider: ${m.provider}
+`;
+    yaml += `    name: ${m.name}
+`;
+    yaml += `    input_per_mtok: ${m.input_per_mtok.toFixed(2)}
+`;
+    yaml += `    output_per_mtok: ${m.output_per_mtok.toFixed(2)}
+`;
+    yaml += `    cache_read_per_mtok: ${m.cache_read_per_mtok.toFixed(2)}
+`;
+    yaml += `    batch_discount: ${m.batch_discount.toFixed(2)}
+`;
+    yaml += `    tier: ${m.tier}
+
+`;
+  }
+  return yaml;
+}
+function generateAgentsYaml(recommendations) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  let yaml = `# Agent/model recommendation mappings
+`;
+  yaml += `# Maps task categories to recommended models
+`;
+  yaml += `# Last updated: ${date}
+
+`;
+  yaml += `recommendations:
+`;
+  for (const [category, rec] of Object.entries(recommendations)) {
+    yaml += `  ${category}:
+`;
+    yaml += `    model: ${rec.model}
+`;
+    yaml += `    reason: ${rec.reason}
+
+`;
+  }
+  return yaml;
+}
+
+// src/commands/research.ts
+function findDataDir2() {
+  const bundled = resolve13(import.meta.dirname ?? __dirname, "data");
+  if (existsSync13(resolve13(bundled, "models.yaml"))) return bundled;
+  return resolve13(import.meta.dirname ?? __dirname, "../../../../data");
+}
+var researchCommand = new Command14("research").description("Check and update model pricing data (fetches live data)").option("--update", "Update local data files with latest pricing").option("--sync", "Also sync updated pricing to Convex").option("--check", "Check for differences without updating (default)").option("--offline", "Skip remote fetches, use local data only").option("--verbose", "Show fetch sources and timing details").action(async (options) => {
+  console.log(chalk15.bold("\nFathom \u2014 Research: Model Pricing"));
+  console.log(chalk15.dim("\u2500".repeat(55)));
+  const startTime = Date.now();
+  let localData;
+  try {
+    localData = loadData();
+  } catch {
+    console.log(chalk15.yellow("  Warning: could not load local data files"));
+    localData = { models: [], recommendations: {} };
+  }
+  const [pricingResult, intelligenceResult] = await Promise.all([
+    fetchPricing({ offline: options.offline, verbose: options.verbose }),
+    fetchIntelligence(localData.models, localData.recommendations, {
+      offline: options.offline,
+      verbose: options.verbose
+    })
+  ]);
+  if (options.verbose) {
+    const elapsed = Date.now() - startTime;
+    console.log(chalk15.dim(`
+  Fetch time: ${elapsed}ms`));
+    console.log(chalk15.dim(`  Pricing source: ${pricingResult.source}`));
+    if (intelligenceResult) {
+      console.log(chalk15.dim(`  Intelligence source: ${intelligenceResult.source}`));
+    }
+  }
+  if (pricingResult.stale) {
+    console.log(chalk15.yellow(`
+  \u26A0 Using local data (${pricingResult.error ?? "stale"})`));
+  } else {
+    console.log(chalk15.green(`
+  Pricing: live data (manifest v${pricingResult.data.manifestVersion}, ${pricingResult.data.manifestDate})`));
+  }
+  const mergeResult = mergePricingData(
+    localData.models,
+    pricingResult.data.models,
+    localData.recommendations,
+    pricingResult.data.recommendations,
+    intelligenceResult?.data.suggestions ?? []
+  );
+  displayPricingReport(mergeResult);
+  if (intelligenceResult?.data) {
+    displayIntelligence(intelligenceResult.data);
+  }
+  displayRecommendations(mergeResult);
+  if (options.update) {
+    const dataDir = findDataDir2();
+    const modelsPath = resolve13(dataDir, "models.yaml");
+    const agentsPath = resolve13(dataDir, "agents.yaml");
+    writeFileSync6(modelsPath, generateModelsYaml(mergeResult.models.merged));
+    console.log(chalk15.green(`
+  Updated: ${modelsPath}`));
+    writeFileSync6(agentsPath, generateAgentsYaml(mergeResult.recommendations.merged));
+    console.log(chalk15.green(`  Updated: ${agentsPath}`));
+  }
+  if (options.sync) {
+    await syncToConvex(mergeResult);
+  }
+  if (options.verbose) {
+    const totalElapsed = Date.now() - startTime;
+    console.log(chalk15.dim(`
+  Total time: ${totalElapsed}ms`));
+  }
+  console.log();
+});
+function displayPricingReport(result) {
+  const { models } = result;
+  if (models.added === 0 && models.updated === 0) {
+    console.log(chalk15.green(`  All model pricing is up to date.`));
+    console.log(chalk15.dim(`  ${models.merged.length} models checked.`));
+  } else {
+    if (models.updated > 0) {
+      console.log(chalk15.yellow(`
+  ${models.updated} pricing change(s) found:`));
+      for (const change of models.changes) {
+        if (change.status === "updated" && change.fields) {
+          for (const f of change.fields) {
+            console.log(chalk15.dim(`    ${change.name}: ${f.field} ${f.old} \u2192 ${f.new}`));
+          }
+        }
+      }
+    }
+    if (models.added > 0) {
+      console.log(chalk15.yellow(`
+  ${models.added} new model(s) found:`));
+      for (const change of models.changes) {
+        if (change.status === "added") {
+          const m = models.merged.find((x) => x.id === change.id);
+          if (m) {
+            console.log(
+              chalk15.dim(`    ${m.name} (${m.tier}): $${m.input_per_mtok}/$${m.output_per_mtok} per MTok`)
+            );
+          }
+        }
+      }
+    }
+  }
+}
+function displayIntelligence(intelligence) {
+  if (intelligence.suggestions.length === 0) {
+    console.log(chalk15.dim(`
+  Intelligence: ${intelligence.summary}`));
+    return;
+  }
+  console.log(chalk15.cyan(`
+  Intelligence suggestions (${intelligence.suggestions.length}):`));
+  for (const s of intelligence.suggestions) {
+    const badge = s.confidence === "high" ? chalk15.red("HIGH") : s.confidence === "medium" ? chalk15.yellow("MED") : chalk15.dim("LOW");
+    const model = s.model ? chalk15.dim(` [${s.model}]`) : "";
+    console.log(`    ${badge} ${s.description}${model}`);
+  }
+  console.log(chalk15.dim(`  Summary: ${intelligence.summary}`));
+  console.log(chalk15.dim(`  Note: Task profiles are team-calibrated and shown as suggestions only.`));
+}
+function displayRecommendations(result) {
+  const { recommendations } = result;
+  if (recommendations.updated > 0 || recommendations.added > 0) {
+    console.log(chalk15.yellow(`
+  Recommendation changes:`));
+    for (const change of recommendations.changes) {
+      if (change.status === "updated") {
+        console.log(chalk15.dim(`    ${change.category}: ${change.oldModel} \u2192 ${change.newModel}`));
+      } else if (change.status === "added") {
+        console.log(chalk15.dim(`    ${change.category}: ${change.newModel} (new)`));
+      }
+    }
+  }
+  console.log(chalk15.dim("\n  Current model recommendations:"));
+  console.log(chalk15.dim("    S/M complexity \u2192 Haiku 4.5 ($1/$5 per MTok) \u2014 fast, cheap"));
+  console.log(chalk15.dim("    L complexity   \u2192 Sonnet 4.6 ($3/$15 per MTok) \u2014 balanced"));
+  console.log(chalk15.dim("    XL complexity  \u2192 Opus 4.6 ($15/$75 per MTok) \u2014 highest quality"));
+  console.log(
+    chalk15.dim("\n    Tip: Enable prompt caching to save 90% on input tokens for repeated context.")
+  );
+}
+async function syncToConvex(result) {
+  const client = getConvexClient();
+  if (!client) {
+    logConvexStatus(false);
+    return;
+  }
+  let synced = 0;
+  for (const m of result.models.merged) {
+    try {
+      await client.mutation(api.modelPricing.upsert, {
+        model: m.name,
+        provider: m.provider,
+        inputPerMTok: m.input_per_mtok,
+        outputPerMTok: m.output_per_mtok,
+        cacheReadPerMTok: m.cache_read_per_mtok,
+        batchDiscount: m.batch_discount
+      });
+      synced++;
+    } catch {
+    }
+  }
+  logConvexStatus(synced > 0);
+  if (synced > 0) {
+    console.log(chalk15.dim(`  ${synced} models synced to Convex.`));
+  }
+}
+
 // src/index.ts
-var program = new Command13();
+var program = new Command15();
 program.name("fathom").description("Workflow intelligence platform for AI-augmented development").version(VERSION);
 program.addCommand(analyzeCommand);
 program.addCommand(pricingCommand);
@@ -17956,6 +18593,8 @@ program.addCommand(validateCommand);
 program.addCommand(velocityCommand);
 program.addCommand(intakeCommand);
 program.addCommand(initCommand);
+program.addCommand(renameCommand);
+program.addCommand(researchCommand);
 program.parse();
 /*! Bundled license information: