hiregraph 0.1.0

package/dist/index.js

@@ -0,0 +1,3282 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import inquirer from "inquirer";
+import { existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+
+// src/storage/store.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+var HIREGRAPH_DIR = join(homedir(), ".hiregraph");
+async function ensureDir() {
+  if (!existsSync(HIREGRAPH_DIR)) {
+    await mkdir(HIREGRAPH_DIR, { recursive: true });
+  }
+}
+function getPath(filename) {
+  return join(HIREGRAPH_DIR, filename);
+}
+async function loadJson(filename) {
+  const filepath = getPath(filename);
+  if (!existsSync(filepath)) return null;
+  const raw = await readFile(filepath, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveJson(filename, data) {
+  await ensureDir();
+  const filepath = getPath(filename);
+  await writeFile(filepath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function ensureSubDir(subdir) {
+  const dirPath = join(HIREGRAPH_DIR, subdir);
+  if (!existsSync(dirPath)) {
+    await mkdir(dirPath, { recursive: true });
+  }
+}
+async function loadSubJson(subdir, filename) {
+  await ensureSubDir(subdir);
+  const filepath = join(HIREGRAPH_DIR, subdir, filename);
+  if (!existsSync(filepath)) return null;
+  const raw = await readFile(filepath, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveSubJson(subdir, filename, data) {
+  await ensureSubDir(subdir);
+  const filepath = join(HIREGRAPH_DIR, subdir, filename);
+  await writeFile(filepath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+// src/resume/parser.ts
+import { readFile as readFile2 } from "fs/promises";
+import { extname } from "path";
+
+// src/llm/client.ts
+import Anthropic from "@anthropic-ai/sdk";
+var client = null;
+function isApiKeyConfigured() {
+  return !!process.env.ANTHROPIC_API_KEY;
+}
+function getClient() {
+  if (!client) {
+    client = new Anthropic();
+  }
+  return client;
+}
+async function callHaiku(systemPrompt, userPrompt) {
+  const anthropic = getClient();
+  const message = await anthropic.messages.create({
+    model: "claude-haiku-4-5-20251001",
+    max_tokens: 1024,
+    system: systemPrompt,
+    messages: [{ role: "user", content: userPrompt }]
+  });
+  const block = message.content[0];
+  if (block.type === "text") {
+    return block.text;
+  }
+  throw new Error("Unexpected response format from Haiku");
+}
+async function callHaikuJson(systemPrompt, userPrompt, maxTokens = 1024) {
+  const anthropic = getClient();
+  const message = await anthropic.messages.create({
+    model: "claude-haiku-4-5-20251001",
+    max_tokens: maxTokens,
+    system: systemPrompt,
+    messages: [{ role: "user", content: userPrompt }]
+  });
+  const block = message.content[0];
+  if (block.type !== "text") throw new Error("Unexpected response format from Haiku");
+  const cleaned = block.text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+  return JSON.parse(cleaned);
+}
+
+// src/resume/parser.ts
+var SYSTEM_PROMPT = `You extract structured data from resume text.
+Return JSON only, no markdown fences. Schema:
+{
+  "name": "string",
+  "email": "string",
+  "phone": "string or null",
+  "links": { "github": "url", "linkedin": "url", "portfolio": "url" },
+  "work_history": [{ "company": "string", "role": "string", "start_year": number, "end_year": number|null }],
+  "skills": ["string array"],
+  "education": [{ "institution": "string", "degree": "string", "field": "string", "year": number }]
+}`;
+async function parseResume(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  let text;
+  if (ext === ".pdf") {
+    const pdfParse = (await import("pdf-parse")).default;
+    const buffer = await readFile2(filePath);
+    const data = await pdfParse(buffer);
+    text = data.text;
+  } else if (ext === ".txt" || ext === ".md") {
+    text = await readFile2(filePath, "utf-8");
+  } else {
+    throw new Error(`Unsupported resume format: ${ext}. Supported: .pdf, .txt, .md`);
+  }
+  if (!isApiKeyConfigured()) {
+    throw new Error("No API key detected. Run hiregraph inside Claude Code or Cursor for resume parsing.");
+  }
+  const response = await callHaiku(SYSTEM_PROMPT, `Extract structured data from this resume:
+
+${text}`);
+  const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+  const parsed = JSON.parse(cleaned);
+  return {
+    name: parsed.name || "",
+    email: parsed.email || "",
+    phone: parsed.phone || void 0,
+    links: parsed.links || {},
+    work_history: (parsed.work_history || []).map((w) => ({
+      company: w.company || "",
+      role: w.role || "",
+      start_year: w.start_year || 0,
+      end_year: w.end_year || void 0
+    })),
+    skills: parsed.skills || [],
+    education: (parsed.education || []).map((e) => ({
+      institution: e.institution || "",
+      degree: e.degree || "",
+      field: e.field || "",
+      year: e.year || 0
+    }))
+  };
+}
+function resumeToIdentity(parsed, role, targetRoles, remotePref, minComp) {
+  return {
+    name: parsed.name,
+    email: parsed.email,
+    phone: parsed.phone,
+    primary_role: role,
+    target_roles: targetRoles,
+    remote_preference: remotePref,
+    min_compensation: minComp,
+    previous_companies: parsed.work_history,
+    education: parsed.education,
+    links: parsed.links,
+    source: "resume-upload"
+  };
+}
+
+// src/graph/schema.ts
+function createEmptySkillGraph(identity) {
+  return {
+    builder_identity: identity,
+    tech_stack: {},
+    architecture: {},
+    quality: {
+      test_ratio: 0,
+      complexity_avg: 0,
+      type_safety: false,
+      secrets_clean: true
+    },
+    projects: [],
+    builder_profile: {
+      is_end_to_end: false,
+      role_signals: []
+    },
+    last_updated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/graph/skill-graph.ts
+var GRAPH_FILE = "skill-graph.json";
+async function loadGraph() {
+  return loadJson(GRAPH_FILE);
+}
+async function saveGraph(graph) {
+  graph.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+  await saveJson(GRAPH_FILE, graph);
+}
+function buildProjectEntry(scan) {
+  return {
+    name: scan.project_name,
+    path: scan.project_path,
+    domain: scan.llm_classification?.domain || "unknown",
+    stack: [
+      ...scan.dependencies.frameworks,
+      ...Object.keys(scan.file_discovery.languages)
+    ],
+    languages: scan.file_discovery.languages,
+    commits: scan.git_forensics.commits,
+    active_days: scan.git_forensics.active_days,
+    contributors: scan.git_forensics.contributors,
+    test_ratio: scan.quality_signals.test_ratio,
+    complexity_avg: scan.quality_signals.complexity_avg,
+    patterns: scan.architecture_patterns.patterns,
+    description: scan.llm_classification?.description || "",
+    scanned_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function mergeIntoGraph(graph, project, classification) {
+  const existingIdx = graph.projects.findIndex((p) => p.path === project.path);
+  if (existingIdx >= 0) {
+    graph.projects[existingIdx] = project;
+  } else {
+    graph.projects.push(project);
+  }
+  graph.tech_stack = {};
+  for (const proj of graph.projects) {
+    for (const [lang, stats] of Object.entries(proj.languages)) {
+      if (!graph.tech_stack[lang]) {
+        graph.tech_stack[lang] = {
+          proficiency: 0,
+          source: "code-verified",
+          loc: 0,
+          projects: 0,
+          advanced_features: [],
+          last_seen: proj.scanned_at
+        };
+      }
+      const skill = graph.tech_stack[lang];
+      skill.loc += stats.loc;
+      skill.projects += 1;
+      if (proj.scanned_at > skill.last_seen) {
+        skill.last_seen = proj.scanned_at;
+      }
+    }
+    for (const fw of proj.stack) {
+      if (!graph.tech_stack[fw]) {
+        graph.tech_stack[fw] = {
+          proficiency: 0,
+          source: "code-verified",
+          loc: 0,
+          projects: 0,
+          advanced_features: [],
+          last_seen: proj.scanned_at
+        };
+      }
+      if (!proj.languages[fw]) {
+        graph.tech_stack[fw].projects += 1;
+      }
+    }
+  }
+  for (const skill of Object.values(graph.tech_stack)) {
+    skill.proficiency = calculateProficiency(skill);
+  }
+  graph.architecture = {};
+  for (const proj of graph.projects) {
+    for (const [pattern, confidence] of Object.entries(proj.patterns)) {
+      if (!graph.architecture[pattern] || confidence > graph.architecture[pattern].confidence) {
+        graph.architecture[pattern] = { confidence };
+      }
+    }
+  }
+  graph.quality = averageQuality(graph.projects);
+  if (classification) {
+    graph.builder_profile = {
+      is_end_to_end: classification.is_end_to_end || graph.builder_profile.is_end_to_end,
+      role_signals: [.../* @__PURE__ */ new Set([
+        ...graph.builder_profile.role_signals,
+        ...classification.role_signals
+      ])]
+    };
+  }
+  return graph;
+}
+function calculateProficiency(skill) {
+  const locScore = Math.min(1, skill.loc / 5e4) * 0.4;
+  const projectScore = Math.min(1, skill.projects / 10) * 0.3;
+  const featureScore = Math.min(1, skill.advanced_features.length / 5) * 0.3;
+  return Math.round(Math.min(1, locScore + projectScore + featureScore) * 100) / 100;
+}
+function averageQuality(projects) {
+  if (projects.length === 0) {
+    return { test_ratio: 0, complexity_avg: 0, type_safety: false, secrets_clean: true };
+  }
+  const testRatio = projects.reduce((sum, p) => sum + p.test_ratio, 0) / projects.length;
+  const complexity = projects.reduce((sum, p) => sum + p.complexity_avg, 0) / projects.length;
+  return {
+    test_ratio: Math.round(testRatio * 100) / 100,
+    complexity_avg: Math.round(complexity * 10) / 10,
+    type_safety: false,
+    // Will be updated per-project
+    secrets_clean: true
+  };
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+function info(msg) {
+  console.log(chalk.cyan(msg));
+}
+function success(msg) {
+  console.log(chalk.green(msg));
+}
+function warn(msg) {
+  console.log(chalk.yellow(msg));
+}
+function error(msg) {
+  console.log(chalk.red(msg));
+}
+function header(msg) {
+  console.log(chalk.bold.white(msg));
+}
+function dim(msg) {
+  console.log(chalk.dim(msg));
+}
+function layerOutput(label, detail) {
+  console.log(`  ${chalk.cyan(label.padEnd(28))} ${detail}`);
+}
+
+// src/utils/spinner.ts
+import ora from "ora";
+var current = null;
+function start(text) {
+  if (current) current.stop();
+  current = ora(text).start();
+  return current;
+}
+function succeed(text) {
+  if (current) {
+    current.succeed(text);
+    current = null;
+  }
+}
+function fail(text) {
+  if (current) {
+    current.fail(text);
+    current = null;
+  }
+}
+
+// src/commands/init.ts
+var ROLE_CHOICES = [
+  { name: "Engineer", value: "engineer" },
+  { name: "PM", value: "pm" },
+  { name: "Designer", value: "designer" },
+  { name: "Founder", value: "founder" },
+  { name: "Builder", value: "builder" }
+];
+async function initCommand() {
+  header("\n  HireGraph Init\n");
+  const existing = await loadJson("identity.json");
+  if (existing) {
+    const { overwrite } = await inquirer.prompt([{
+      type: "confirm",
+      name: "overwrite",
+      message: "Profile already exists. Overwrite?",
+      default: false
+    }]);
+    if (!overwrite) {
+      info("Keeping existing profile.");
+      return;
+    }
+  }
+  const { name, email } = await inquirer.prompt([
+    { type: "input", name: "name", message: "Name:" },
+    { type: "input", name: "email", message: "Email:" }
+  ]);
+  let resumeData = null;
+  const { hasResume } = await inquirer.prompt([{
+    type: "confirm",
+    name: "hasResume",
+    message: "Do you have an existing resume? (PDF/TXT)",
+    default: true
+  }]);
+  if (hasResume) {
+    if (!isApiKeyConfigured()) {
+      warn("No API key detected. Run inside Claude Code for resume parsing. Using manual flow.");
+    } else {
+      const { resumePath } = await inquirer.prompt([{
+        type: "input",
+        name: "resumePath",
+        message: "Path to resume:"
+      }]);
+      const resolved = resolve(resumePath.trim().replace(/^["']|["']$/g, ""));
+      if (existsSync2(resolved)) {
+        start("Parsing resume...");
+        try {
+          resumeData = await parseResume(resolved);
+          succeed("Resume parsed");
+          info(`  Name: ${resumeData.name}`);
+          info(`  Email: ${resumeData.email}`);
+          if (resumeData.work_history.length > 0) {
+            info("  Work History:");
+            for (const w of resumeData.work_history) {
+              info(`    ${w.role} @ ${w.company} (${w.start_year}-${w.end_year || "present"})`);
+            }
+          }
+          if (resumeData.skills.length > 0) {
+            info(`  Skills: ${resumeData.skills.join(", ")}`);
+          }
+          const { looksRight } = await inquirer.prompt([{
+            type: "confirm",
+            name: "looksRight",
+            message: "Look right?",
+            default: true
+          }]);
+          if (!looksRight) {
+            info("Resume data discarded. Using manual input.");
+            resumeData = null;
+          }
+        } catch (err) {
+          fail("Failed to parse resume");
+          error(err.message);
+          resumeData = null;
+        }
+      } else {
+        warn("File not found. Continuing without resume.");
+      }
+    }
+  }
+  const { role } = await inquirer.prompt([{
+    type: "list",
+    name: "role",
+    message: "What describes you best?",
+    choices: ROLE_CHOICES
+  }]);
+  const { targetRoles } = await inquirer.prompt([{
+    type: "input",
+    name: "targetRoles",
+    message: "Target roles (comma separated):",
+    default: "Founding Engineer, Full-Stack Engineer"
+  }]);
+  const { remotePref } = await inquirer.prompt([{
+    type: "list",
+    name: "remotePref",
+    message: "Remote preference?",
+    choices: ["Remote", "Hybrid", "Onsite", "No preference"]
+  }]);
+  const { minComp } = await inquirer.prompt([{
+    type: "input",
+    name: "minComp",
+    message: "Min compensation (optional):",
+    default: ""
+  }]);
+  const targets = targetRoles.split(",").map((r) => r.trim()).filter(Boolean);
+  const identity = resumeData ? resumeToIdentity(resumeData, role, targets, remotePref, minComp) : {
+    name,
+    email,
+    primary_role: role,
+    target_roles: targets,
+    remote_preference: remotePref,
+    min_compensation: minComp,
+    previous_companies: [],
+    education: [],
+    links: {},
+    source: "manual"
+  };
+  if (name) identity.name = name;
+  if (email) identity.email = email;
+  await saveJson("identity.json", identity);
+  await saveJson("config.json", { excluded_companies: [], auto_apply_threshold: 8 });
+  const graph = createEmptySkillGraph(identity);
+  await saveGraph(graph);
+  success("\nProfile saved to ~/.hiregraph/identity.json");
+  info("Run `hiregraph scan <path>` to analyze your first project.");
+}
+
+// src/commands/scan.ts
+import { resolve as resolve2, basename } from "path";
+import { existsSync as existsSync8 } from "fs";
+
+// src/layers/file-discovery.ts
+import { readdir, readFile as readFile4 } from "fs/promises";
+import { join as join3, extname as extname2, relative } from "path";
+
+// src/utils/gitignore.ts
+import ignore from "ignore";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+var DEFAULT_IGNORES = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "__pycache__",
+  ".pytest_cache",
+  "target",
+  "vendor",
+  ".venv",
+  "venv",
+  "env",
+  ".tox",
+  ".mypy_cache",
+  "coverage",
+  ".nyc_output",
+  ".turbo",
+  ".vercel",
+  ".expo",
+  ".cache"
+];
+async function createFilter(projectPath) {
+  const ig = ignore();
+  ig.add(DEFAULT_IGNORES);
+  const gitignorePath = join2(projectPath, ".gitignore");
+  if (existsSync3(gitignorePath)) {
+    const content = await readFile3(gitignorePath, "utf-8");
+    ig.add(content);
+  }
+  return ig;
+}
+
+// src/utils/language-map.ts
+var LANGUAGE_MAP = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript",
+  ".mjs": "JavaScript",
+  ".cjs": "JavaScript",
+  ".py": "Python",
+  ".rs": "Rust",
+  ".go": "Go",
+  ".java": "Java",
+  ".kt": "Kotlin",
+  ".kts": "Kotlin",
+  ".swift": "Swift",
+  ".rb": "Ruby",
+  ".php": "PHP",
+  ".c": "C",
+  ".h": "C",
+  ".cpp": "C++",
+  ".cc": "C++",
+  ".cxx": "C++",
+  ".hpp": "C++",
+  ".cs": "C#",
+  ".dart": "Dart",
+  ".lua": "Lua",
+  ".r": "R",
+  ".R": "R",
+  ".scala": "Scala",
+  ".ex": "Elixir",
+  ".exs": "Elixir",
+  ".erl": "Erlang",
+  ".hs": "Haskell",
+  ".clj": "Clojure",
+  ".vue": "Vue",
+  ".svelte": "Svelte",
+  ".sol": "Solidity",
+  ".zig": "Zig",
+  ".nim": "Nim",
+  ".ml": "OCaml",
+  ".sh": "Shell",
+  ".bash": "Shell",
+  ".zsh": "Shell",
+  ".sql": "SQL"
+};
+var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".bmp",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".wav",
+  ".ogg",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".pptx",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".lock",
+  ".map"
+]);
+function getLanguage(ext) {
+  return LANGUAGE_MAP[ext] ?? null;
+}
+function shouldSkip(ext) {
+  return SKIP_EXTENSIONS.has(ext);
+}
+
+// src/layers/file-discovery.ts
+var CONFIG_PATTERNS = [
+  "Dockerfile",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  ".github",
+  ".gitlab-ci.yml",
+  ".circleci",
+  "tsconfig.json",
+  "jest.config",
+  "vitest.config",
+  "vite.config",
+  ".eslintrc",
+  ".prettierrc",
+  "prettier.config",
+  "biome.json",
+  "ruff.toml",
+  ".flake8",
+  "Makefile",
+  "Procfile",
+  "vercel.json",
+  "netlify.toml",
+  "turbo.json",
+  "lerna.json"
+];
+async function analyzeFileDiscovery(projectPath) {
+  const ig = await createFilter(projectPath);
+  const files = [];
+  const configFiles = [];
+  await walkDir(projectPath, projectPath, ig, files, configFiles);
+  const languages = {};
+  let totalLoc = 0;
+  for (const file of files) {
+    if (!languages[file.language]) {
+      languages[file.language] = { files: 0, loc: 0 };
+    }
+    languages[file.language].files++;
+    languages[file.language].loc += file.loc;
+    totalLoc += file.loc;
+  }
+  let primaryLanguage = "";
+  let maxLoc = 0;
+  for (const [lang, stats] of Object.entries(languages)) {
+    if (stats.loc > maxLoc) {
+      maxLoc = stats.loc;
+      primaryLanguage = lang;
+    }
+  }
+  return {
+    total_files: files.length,
+    total_loc: totalLoc,
+    languages,
+    config_files: configFiles,
+    primary_language: primaryLanguage
+  };
+}
+async function walkDir(basePath, currentPath, ig, files, configFiles) {
+  const entries = await readdir(currentPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(currentPath, entry.name);
+    const relPath = relative(basePath, fullPath).replace(/\\/g, "/");
+    if (ig.ignores(relPath)) continue;
+    if (entry.isDirectory()) {
+      if (CONFIG_PATTERNS.some((p) => entry.name === p || entry.name.startsWith(p))) {
+        configFiles.push(entry.name);
+      }
+      await walkDir(basePath, fullPath, ig, files, configFiles);
+    } else if (entry.isFile()) {
+      const ext = extname2(entry.name).toLowerCase();
+      if (CONFIG_PATTERNS.some((p) => entry.name === p || entry.name.startsWith(p))) {
+        configFiles.push(entry.name);
+      }
+      if (shouldSkip(ext)) continue;
+      const language = getLanguage(ext);
+      if (!language) continue;
+      try {
+        const content = await readFile4(fullPath, "utf-8");
+        const loc = countLines(content);
+        files.push({ relativePath: relPath, language, loc });
+      } catch {
+      }
+    }
+  }
+}
+function countLines(content) {
+  const lines = content.split("\n");
+  let count = 0;
+  for (const line of lines) {
+    if (line.trim().length > 0) count++;
+  }
+  return count;
+}
+
+// src/layers/dependency-extraction.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join4 } from "path";
+import { existsSync as existsSync4 } from "fs";
+var FRAMEWORK_MAP = {
+  // Frontend
+  "react": "React",
+  "react-dom": "React",
+  "next": "Next.js",
+  "vue": "Vue",
+  "nuxt": "Nuxt",
+  "svelte": "Svelte",
+  "@sveltejs/kit": "SvelteKit",
+  "angular": "Angular",
+  "@angular/core": "Angular",
+  "solid-js": "Solid",
+  "astro": "Astro",
+  "gatsby": "Gatsby",
+  "remix": "Remix",
+  // Mobile
+  "react-native": "React Native",
+  "expo": "Expo",
+  "flutter": "Flutter",
+  // Backend
+  "express": "Express",
+  "fastify": "Fastify",
+  "koa": "Koa",
+  "hono": "Hono",
+  "nestjs": "NestJS",
+  "@nestjs/core": "NestJS",
+  // Database
+  "prisma": "Prisma",
+  "@prisma/client": "Prisma",
+  "drizzle-orm": "Drizzle",
+  "typeorm": "TypeORM",
+  "sequelize": "Sequelize",
+  "mongoose": "Mongoose",
+  "@supabase/supabase-js": "Supabase",
+  "firebase": "Firebase",
+  // Python frameworks (from requirements.txt)
+  "django": "Django",
+  "flask": "Flask",
+  "fastapi": "FastAPI",
+  "tornado": "Tornado",
+  "starlette": "Starlette",
+  "sqlalchemy": "SQLAlchemy",
+  "pandas": "Pandas",
+  "numpy": "NumPy",
+  "tensorflow": "TensorFlow",
+  "torch": "PyTorch",
+  "pytorch": "PyTorch",
+  // Rust frameworks
+  "actix-web": "Actix",
+  "axum": "Axum",
+  "rocket": "Rocket",
+  "warp": "Warp",
+  "tokio": "Tokio",
+  "serde": "Serde",
+  // Go frameworks
+  "github.com/gin-gonic/gin": "Gin",
+  "github.com/gofiber/fiber": "Fiber",
+  "github.com/labstack/echo": "Echo",
+  // AI/ML
+  "@anthropic-ai/sdk": "Anthropic SDK",
+  "openai": "OpenAI",
+  "langchain": "LangChain",
+  "@langchain/core": "LangChain"
+};
+async function analyzeDependencies(projectPath) {
+  const deps = [];
+  const devDeps = [];
+  const frameworks = /* @__PURE__ */ new Set();
+  let ecosystem = "unknown";
+  let hasLockfile = false;
+  const pkgPath = join4(projectPath, "package.json");
+  if (existsSync4(pkgPath)) {
+    ecosystem = "node";
+    hasLockfile = existsSync4(join4(projectPath, "package-lock.json")) || existsSync4(join4(projectPath, "yarn.lock")) || existsSync4(join4(projectPath, "pnpm-lock.yaml")) || existsSync4(join4(projectPath, "bun.lockb"));
+    try {
+      const pkg = JSON.parse(await readFile5(pkgPath, "utf-8"));
+      if (pkg.dependencies) {
+        for (const dep of Object.keys(pkg.dependencies)) {
+          deps.push(dep);
+          const fw = FRAMEWORK_MAP[dep];
+          if (fw) frameworks.add(fw);
+        }
+      }
+      if (pkg.devDependencies) {
+        for (const dep of Object.keys(pkg.devDependencies)) {
+          devDeps.push(dep);
+          const fw = FRAMEWORK_MAP[dep];
+          if (fw) frameworks.add(fw);
+        }
+      }
+    } catch {
+    }
+  }
+  const reqPath = join4(projectPath, "requirements.txt");
+  if (existsSync4(reqPath)) {
+    ecosystem = ecosystem === "node" ? "multi" : "python";
+    hasLockfile = hasLockfile || existsSync4(join4(projectPath, "Pipfile.lock")) || existsSync4(join4(projectPath, "poetry.lock"));
+    try {
+      const content = await readFile5(reqPath, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) continue;
+        const name = trimmed.split(/[=<>!~]/)[0].trim().toLowerCase();
+        if (name) {
+          deps.push(name);
+          const fw = FRAMEWORK_MAP[name];
+          if (fw) frameworks.add(fw);
+        }
+      }
+    } catch {
+    }
+  }
+  const pyprojectPath = join4(projectPath, "pyproject.toml");
+  if (existsSync4(pyprojectPath)) {
+    ecosystem = ecosystem === "unknown" ? "python" : ecosystem === "python" ? "python" : "multi";
+    try {
+      const content = await readFile5(pyprojectPath, "utf-8");
+      const depMatches = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+      if (depMatches) {
+        const items = depMatches[1].match(/"([^"]+)"/g);
+        if (items) {
+          for (const item of items) {
+            const name = item.replace(/"/g, "").split(/[=<>!~]/)[0].trim().toLowerCase();
+            if (name && !deps.includes(name)) {
+              deps.push(name);
+              const fw = FRAMEWORK_MAP[name];
+              if (fw) frameworks.add(fw);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const cargoPath = join4(projectPath, "Cargo.toml");
+  if (existsSync4(cargoPath)) {
+    ecosystem = ecosystem === "unknown" ? "rust" : "multi";
+    hasLockfile = hasLockfile || existsSync4(join4(projectPath, "Cargo.lock"));
+    try {
+      const content = await readFile5(cargoPath, "utf-8");
+      const depSection = content.match(/\[dependencies\]([\s\S]*?)(?=\[|$)/);
+      if (depSection) {
+        for (const line of depSection[1].split("\n")) {
+          const match = line.match(/^(\S+)\s*=/);
+          if (match) {
+            const name = match[1].trim();
+            deps.push(name);
+            const fw = FRAMEWORK_MAP[name];
+            if (fw) frameworks.add(fw);
+          }
+        }
+      }
+      const devSection = content.match(/\[dev-dependencies\]([\s\S]*?)(?=\[|$)/);
+      if (devSection) {
+        for (const line of devSection[1].split("\n")) {
+          const match = line.match(/^(\S+)\s*=/);
+          if (match) devDeps.push(match[1].trim());
+        }
+      }
+    } catch {
+    }
+  }
+  const goModPath = join4(projectPath, "go.mod");
+  if (existsSync4(goModPath)) {
+    ecosystem = ecosystem === "unknown" ? "go" : "multi";
+    hasLockfile = hasLockfile || existsSync4(join4(projectPath, "go.sum"));
+    try {
+      const content = await readFile5(goModPath, "utf-8");
+      const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/);
+      if (requireBlock) {
+        for (const line of requireBlock[1].split("\n")) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("//")) continue;
+          const parts = trimmed.split(/\s+/);
+          if (parts[0]) {
+            deps.push(parts[0]);
+            const fw = FRAMEWORK_MAP[parts[0]];
+            if (fw) frameworks.add(fw);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    ecosystem,
+    dependencies: deps,
+    dev_dependencies: devDeps,
+    frameworks: [...frameworks],
+    has_lockfile: hasLockfile
+  };
+}
+
+// src/layers/ast-analysis.ts
+import { readFile as readFile6, readdir as readdir2 } from "fs/promises";
+import { join as join5, extname as extname3, relative as relative2 } from "path";
+var MAX_FILES = 100;
+async function analyzeAst(projectPath, languages) {
+  const ig = await createFilter(projectPath);
+  const files = await collectSourceFiles(projectPath, projectPath, ig);
+  const sampled = files.length > MAX_FILES ? files.sort(() => Math.random() - 0.5).slice(0, MAX_FILES) : files;
+  const totals = {
+    functions: 0,
+    classes: 0,
+    interfaces: 0,
+    components: 0,
+    hooks: 0,
+    services: 0,
+    nestingDepth: 0,
+    paramCounts: [],
+    imports: [],
+    features: []
+  };
+  for (const filePath of sampled) {
+    try {
+      const content = await readFile6(filePath, "utf-8");
+      const ext = extname3(filePath).toLowerCase();
+      const analysis = analyzeFile(content, ext);
+      totals.functions += analysis.functions;
+      totals.classes += analysis.classes;
+      totals.interfaces += analysis.interfaces;
+      totals.components += analysis.components;
+      totals.hooks += analysis.hooks;
+      totals.services += analysis.services;
+      totals.nestingDepth = Math.max(totals.nestingDepth, analysis.nestingDepth);
+      totals.paramCounts.push(...analysis.paramCounts);
+      totals.imports.push(...analysis.imports);
+      totals.features.push(...analysis.features);
+    } catch {
+    }
+  }
+  const uniqueImports = [...new Set(totals.imports)];
+  const uniqueFeatures = [...new Set(totals.features)];
+  const avgParams = totals.paramCounts.length > 0 ? Math.round(totals.paramCounts.reduce((a, b) => a + b, 0) / totals.paramCounts.length * 100) / 100 : 0;
+  return {
+    functions: totals.functions,
+    classes: totals.classes,
+    interfaces: totals.interfaces,
+    components: totals.components,
+    hooks: totals.hooks,
+    services: totals.services,
+    max_nesting_depth: totals.nestingDepth,
+    avg_params_per_function: avgParams,
+    imports_used: uniqueImports,
+    advanced_features: uniqueFeatures
+  };
+}
+function analyzeFile(content, ext) {
+  const result = {
+    functions: 0,
+    classes: 0,
+    interfaces: 0,
+    components: 0,
+    hooks: 0,
+    services: 0,
+    nestingDepth: 0,
+    paramCounts: [],
+    imports: [],
+    features: []
+  };
+  if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
+    analyzeTypeScript(content, ext, result);
+  } else if (ext === ".py") {
+    analyzePython(content, result);
+  } else if (ext === ".rs") {
+    analyzeRust(content, result);
+  } else if (ext === ".go") {
+    analyzeGo(content, result);
+  }
+  return result;
+}
+function analyzeTypeScript(content, ext, result) {
+  const funcMatches = content.match(/(?:function\s+\w+|(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\(|(?:async\s+)?(?:export\s+)?(?:default\s+)?function)/g);
+  if (funcMatches) {
+    result.functions += funcMatches.length;
+    for (const m of funcMatches) {
+      const params = m.match(/\(([^)]*)\)/);
+      if (params && params[1]) {
+        result.paramCounts.push(params[1].split(",").filter((p) => p.trim()).length);
+      }
+    }
+  }
+  const arrowFuncs = content.match(/=>\s*{/g);
+  if (arrowFuncs) result.functions += arrowFuncs.length;
+  const classMatches = content.match(/\bclass\s+\w+/g);
+  if (classMatches) result.classes += classMatches.length;
+  const ifaceMatches = content.match(/\b(?:interface|type)\s+\w+/g);
+  if (ifaceMatches) result.interfaces += ifaceMatches.length;
+  if ([".tsx", ".jsx"].includes(ext)) {
+    const componentMatches = content.match(/(?:export\s+)?(?:default\s+)?function\s+[A-Z]\w*/g);
+    if (componentMatches) result.components += componentMatches.length;
+    const arrowComponents = content.match(/(?:const|export\s+const)\s+[A-Z]\w+\s*[=:]/g);
+    if (arrowComponents) result.components += arrowComponents.length;
+  }
+  const hookMatches = content.match(/(?:function|const)\s+use[A-Z]\w*/g);
+  if (hookMatches) result.hooks += hookMatches.length;
+  const serviceMatches = content.match(/class\s+\w*(?:Service|Repository|Controller)\b/g);
+  if (serviceMatches) result.services += serviceMatches.length;
+  const importMatches = content.matchAll(/import\s+.*?from\s+['"]([^'"]+)['"]/g);
+  for (const m of importMatches) {
+    const pkg = m[1];
+    if (!pkg.startsWith(".") && !pkg.startsWith("/")) {
+      result.imports.push(pkg.split("/").slice(0, pkg.startsWith("@") ? 2 : 1).join("/"));
+    }
+  }
+  if (content.match(/<\w+(?:\s+extends|\s*,)/)) result.features.push("generics");
+  if (content.match(/\bkeyof\b|\bin\s+keyof\b/)) result.features.push("mapped-types");
+  if (content.match(/\binfer\b/)) result.features.push("conditional-types");
+  if (content.match(/@\w+/)) result.features.push("decorators");
+  if (content.match(/\basync\s+/)) result.features.push("async-await");
+  result.nestingDepth = estimateNesting(content);
+}
+function analyzePython(content, result) {
+  const funcMatches = content.match(/\bdef\s+\w+/g);
+  if (funcMatches) result.functions += funcMatches.length;
+  const classMatches = content.match(/\bclass\s+\w+/g);
+  if (classMatches) result.classes += classMatches.length;
+  const importMatches = content.matchAll(/(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
+  for (const m of importMatches) {
+    const pkg = (m[1] || m[2]).split(".")[0];
+    if (pkg && !pkg.startsWith(".")) result.imports.push(pkg);
+  }
+  if (content.match(/@\w+/)) result.features.push("decorators");
+  if (content.match(/@dataclass/)) result.features.push("dataclasses");
+  if (content.match(/->\s*\w+|:\s*\w+\s*[=,)]/)) result.features.push("type-hints");
+  if (content.match(/\basync\s+def\b/)) result.features.push("async-await");
+  const serviceMatches = content.match(/class\s+\w*(?:Service|Repository|Controller)\b/g);
+  if (serviceMatches) result.services += serviceMatches.length;
+  result.nestingDepth = estimateIndentNesting(content);
+}
+function analyzeRust(content, result) {
+  const fnMatches = content.match(/\bfn\s+\w+/g);
+  if (fnMatches) result.functions += fnMatches.length;
+  const structMatches = content.match(/\bstruct\s+\w+/g);
+  if (structMatches) result.classes += structMatches.length;
+  const traitMatches = content.match(/\btrait\s+\w+/g);
+  if (traitMatches) result.interfaces += traitMatches.length;
+  const implMatches = content.match(/\bimpl\b/g);
+  if (implMatches) result.features.push("impl-blocks");
+  const useMatches = content.matchAll(/use\s+(\w+)/g);
+  for (const m of useMatches) {
+    if (m[1] !== "std" && m[1] !== "self" && m[1] !== "super" && m[1] !== "crate") {
+      result.imports.push(m[1]);
+    }
+  }
+  if (content.match(/\basync\s+fn\b/)) result.features.push("async-await");
+  if (content.match(/macro_rules!/)) result.features.push("macros");
+  if (content.match(/<[^>]+>/)) result.features.push("generics");
+  if (content.match(/\bunsafe\b/)) result.features.push("unsafe");
+  result.nestingDepth = estimateNesting(content);
+}
+function analyzeGo(content, result) {
+  const funcMatches = content.match(/\bfunc\s+(?:\([^)]*\)\s*)?\w+/g);
+  if (funcMatches) result.functions += funcMatches.length;
+  const structMatches = content.match(/\btype\s+\w+\s+struct\b/g);
+  if (structMatches) result.classes += structMatches.length;
+  const ifaceMatches = content.match(/\btype\s+\w+\s+interface\b/g);
+  if (ifaceMatches) result.interfaces += ifaceMatches.length;
+  const importBlock = content.match(/import\s*\(([\s\S]*?)\)/);
+  if (importBlock) {
+    const imports = importBlock[1].matchAll(/"([^"]+)"/g);
+    for (const m of imports) {
+      const parts = m[1].split("/");
+      result.imports.push(parts[parts.length - 1]);
+    }
+  }
+  if (content.match(/\bgo\s+\w+/)) result.features.push("goroutines");
+  if (content.match(/\bchan\b/)) result.features.push("channels");
+  if (content.match(/\binterface\s*\{/)) result.features.push("interfaces");
+  result.nestingDepth = estimateNesting(content);
+}
+function estimateNesting(content) {
+  let max = 0;
+  let current2 = 0;
+  for (const char of content) {
+    if (char === "{") {
+      current2++;
+      max = Math.max(max, current2);
+    } else if (char === "}") {
+      current2 = Math.max(0, current2 - 1);
+    }
+  }
+  return max;
+}
+function estimateIndentNesting(content) {
+  let max = 0;
+  for (const line of content.split("\n")) {
+    if (line.trim().length === 0) continue;
+    const indent = line.match(/^(\s*)/);
+    if (indent) {
+      const level = Math.floor(indent[1].length / 4);
+      max = Math.max(max, level);
+    }
+  }
+  return max;
+}
+async function collectSourceFiles(basePath, currentPath, ig) {
+  const files = [];
+  const codeExts = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".rs", ".go"]);
+  const entries = await readdir2(currentPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join5(currentPath, entry.name);
+    const relPath = relative2(basePath, fullPath).replace(/\\/g, "/");
+    if (ig.ignores(relPath)) continue;
+    if (entry.isDirectory()) {
+      files.push(...await collectSourceFiles(basePath, fullPath, ig));
+    } else if (entry.isFile()) {
+      const ext = extname3(entry.name).toLowerCase();
+      if (codeExts.has(ext)) files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+// src/layers/git-forensics.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+var execFileAsync = promisify(execFile);
+var EMPTY_RESULT = {
+  is_git_repo: false,
+  commits: 0,
+  active_days: 0,
+  contributors: 0,
+  commits_per_active_day: 0,
+  active_days_per_week: 0,
+  first_commit: "",
+  last_commit: "",
+  conventional_commit_ratio: 0,
+  branches: 0,
+  primary_author: ""
+};
+var CONVENTIONAL_PREFIXES = [
+  "feat:",
+  "fix:",
+  "refactor:",
+  "docs:",
+  "test:",
+  "chore:",
+  "style:",
+  "perf:",
+  "ci:",
+  "build:",
+  "revert:",
+  "feat(",
+  "fix(",
+  "refactor(",
+  "docs(",
+  "test(",
+  "chore("
+];
+async function analyzeGitForensics(projectPath) {
+  if (!existsSync5(join6(projectPath, ".git"))) {
+    return { ...EMPTY_RESULT };
+  }
+  try {
+    const opts = { cwd: projectPath, maxBuffer: 10 * 1024 * 1024 };
+    const [logResult, branchResult] = await Promise.all([
+      execFileAsync("git", ["log", "--format=%an|%aI|%s", "--all"], opts),
+      execFileAsync("git", ["branch", "-a", "--format=%(refname:short)"], opts)
+    ]);
+    const lines = logResult.stdout.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) return { ...EMPTY_RESULT, is_git_repo: true };
+    const authors = {};
+    const dates = /* @__PURE__ */ new Set();
+    let conventionalCount = 0;
+    let firstDate = "";
+    let lastDate = "";
+    for (const line of lines) {
+      const parts = line.split("|");
+      if (parts.length < 3) continue;
+      const author = parts[0];
+      const date = parts[1];
+      const subject = parts.slice(2).join("|");
+      authors[author] = (authors[author] || 0) + 1;
+      const day = date.slice(0, 10);
+      dates.add(day);
+      if (!lastDate) lastDate = date;
+      firstDate = date;
+      const lowerSubject = subject.toLowerCase().trim();
+      if (CONVENTIONAL_PREFIXES.some((p) => lowerSubject.startsWith(p))) {
+        conventionalCount++;
+      }
+    }
+    const activeDays = dates.size;
+    const commits = lines.length;
+    const firstDateObj = new Date(firstDate);
+    const lastDateObj = new Date(lastDate);
+    const weeksSpan = Math.max(1, (lastDateObj.getTime() - firstDateObj.getTime()) / (7 * 24 * 60 * 60 * 1e3));
+    let primaryAuthor = "";
+    let maxCommits = 0;
+    for (const [author, count] of Object.entries(authors)) {
+      if (count > maxCommits) {
+        maxCommits = count;
+        primaryAuthor = author;
+      }
+    }
+    const branches = branchResult.stdout.trim().split("\n").filter(Boolean).length;
+    return {
+      is_git_repo: true,
+      commits,
+      active_days: activeDays,
+      contributors: Object.keys(authors).length,
+      commits_per_active_day: Math.round(commits / activeDays * 100) / 100,
+      active_days_per_week: Math.round(activeDays / weeksSpan * 100) / 100,
+      first_commit: firstDate,
+      last_commit: lastDate,
+      conventional_commit_ratio: Math.round(conventionalCount / commits * 100) / 100,
+      branches,
+      primary_author: primaryAuthor
+    };
+  } catch {
+    return { ...EMPTY_RESULT, is_git_repo: true };
+  }
+}
+
+// src/layers/quality-signals.ts
+import { readFile as readFile7 } from "fs/promises";
+import { join as join7 } from "path";
+import { existsSync as existsSync6 } from "fs";
+var SECRET_PATTERNS = [
+  /(?:api[_-]?key|apikey)\s*[:=]\s*["'][^"']{8,}["']/i,
+  /AKIA[0-9A-Z]{16}/,
+  /(?:secret|password|credential|token)\s*[:=]\s*["'][^"']{8,}["']/i,
+  /ghp_[a-zA-Z0-9]{36}/,
+  /sk-[a-zA-Z0-9]{20,}/
+];
+var LINT_CONFIGS = [
+  ".eslintrc",
+  ".eslintrc.js",
+  ".eslintrc.json",
+  ".eslintrc.yml",
+  ".eslintrc.yaml",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.ts",
+  ".prettierrc",
+  ".prettierrc.js",
+  ".prettierrc.json",
+  "prettier.config.js",
+  "biome.json",
+  "biome.jsonc",
+  "ruff.toml",
+  ".flake8",
+  "mypy.ini",
+  "clippy.toml",
+  ".clippy.toml",
+  ".golangci.yml",
+  ".golangci.yaml"
+];
+async function analyzeQualitySignals(projectPath, fileDiscovery) {
+  let testLoc = 0;
+  let sourceLoc = 0;
+  for (const [, stats] of Object.entries(fileDiscovery.languages)) {
+    sourceLoc += stats.loc;
+  }
+  testLoc = await estimateTestLoc(projectPath, fileDiscovery);
+  const testRatio = sourceLoc > 0 ? Math.round(testLoc / sourceLoc * 100) / 100 : 0;
+  const { typeSafety, typeSafetyDetails } = await checkTypeSafety(projectPath);
+  const { secretsClean, secretsFound } = await scanSecrets(projectPath);
+  const lintTools = [];
+  for (const config of LINT_CONFIGS) {
+    if (existsSync6(join7(projectPath, config))) {
+      const tool = config.includes("eslint") ? "ESLint" : config.includes("prettier") ? "Prettier" : config.includes("biome") ? "Biome" : config.includes("ruff") ? "Ruff" : config.includes("flake8") ? "Flake8" : config.includes("mypy") ? "mypy" : config.includes("clippy") ? "Clippy" : config.includes("golangci") ? "golangci-lint" : config;
+      if (!lintTools.includes(tool)) lintTools.push(tool);
+    }
+  }
+  const complexityAvg = await estimateComplexity(projectPath, fileDiscovery);
+  return {
+    test_ratio: testRatio,
+    complexity_avg: complexityAvg,
+    type_safety: typeSafety,
+    type_safety_details: typeSafetyDetails,
+    secrets_clean: secretsClean,
+    secrets_found: secretsFound,
+    lint_tools: lintTools
+  };
+}
+async function estimateTestLoc(projectPath, fileDiscovery) {
+  let testLoc = 0;
+  const testDirs = ["__tests__", "tests", "test", "spec"];
+  for (const dir of testDirs) {
+    if (existsSync6(join7(projectPath, dir))) {
+      testLoc += Math.round(fileDiscovery.total_loc * 0.05);
+    }
+  }
+  if (fileDiscovery.config_files.some((f) => f.includes("jest") || f.includes("vitest"))) {
+    testLoc += Math.round(fileDiscovery.total_loc * 0.1);
+  }
+  return Math.min(testLoc, Math.round(fileDiscovery.total_loc * 0.5));
+}
+async function checkTypeSafety(projectPath) {
+  const tsconfigPath = join7(projectPath, "tsconfig.json");
+  if (existsSync6(tsconfigPath)) {
+    try {
+      const content = await readFile7(tsconfigPath, "utf-8");
+      const tsconfig = JSON.parse(content);
+      if (tsconfig.compilerOptions?.strict === true) {
+        return { typeSafety: true, typeSafetyDetails: "TypeScript strict mode" };
+      }
+      return { typeSafety: false, typeSafetyDetails: "TypeScript without strict mode" };
+    } catch {
+    }
+  }
+  if (existsSync6(join7(projectPath, "mypy.ini")) || existsSync6(join7(projectPath, "pyrightconfig.json"))) {
+    return { typeSafety: true, typeSafetyDetails: "Python type checker configured" };
+  }
+  const pyprojectPath = join7(projectPath, "pyproject.toml");
+  if (existsSync6(pyprojectPath)) {
+    try {
+      const content = await readFile7(pyprojectPath, "utf-8");
+      if (content.includes("[tool.mypy]") || content.includes("[tool.pyright]")) {
+        return { typeSafety: true, typeSafetyDetails: "Python type checker configured" };
+      }
+    } catch {
+    }
+  }
+  return { typeSafety: false, typeSafetyDetails: "No type checking configured" };
+}
+async function scanSecrets(projectPath) {
+  let found = 0;
+  const filesToCheck = [".env", ".env.local", ".env.production"];
+  for (const file of filesToCheck) {
+    const filePath = join7(projectPath, file);
+    if (existsSync6(filePath)) {
+      try {
+        const content = await readFile7(filePath, "utf-8");
+        for (const pattern of SECRET_PATTERNS) {
+          const matches = content.match(pattern);
+          if (matches) found += matches.length;
+        }
+      } catch {
+      }
+    }
+  }
+  return { secretsClean: found === 0, secretsFound: found };
+}
+async function estimateComplexity(projectPath, fileDiscovery) {
+  const branchKeywords = /\b(if|else|elif|switch|case|for|while|catch|except|&&|\|\||\?)\b/g;
+  const tsconfigExists = existsSync6(join7(projectPath, "tsconfig.json"));
+  const mainFile = tsconfigExists ? join7(projectPath, "src", "index.ts") : join7(projectPath, "src", "index.js");
+  if (!existsSync6(mainFile)) {
+    return 3.5;
+  }
+  try {
+    const content = await readFile7(mainFile, "utf-8");
+    const branches = (content.match(branchKeywords) || []).length;
+    const functions = (content.match(/\b(function|def|fn|func)\b/g) || []).length || 1;
+    return Math.round(branches / functions * 10) / 10;
+  } catch {
+    return 3.5;
+  }
+}
+
+// src/layers/architecture-patterns.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
+async function analyzeArchitecturePatterns(projectPath, fileDiscovery, astAnalysis) {
+  const patterns = [
+    detectServiceLayer(projectPath, astAnalysis),
+    detectMvc(projectPath),
+    detectEventDriven(astAnalysis),
+    detectRepositoryPattern(astAnalysis),
+    detectMicroservices(projectPath),
+    detectMonorepo(projectPath),
+    detectApiFirst(projectPath, fileDiscovery)
+  ];
+  const result = {};
+  let primaryPattern = null;
+  let highestScore = 0;
+  for (const p of patterns) {
+    const confidence = p.maxSignals > 0 ? Math.round(p.score / p.maxSignals * 100) / 100 : 0;
+    if (confidence >= 0.2) {
+      result[p.name] = confidence;
+      if (confidence > highestScore) {
+        highestScore = confidence;
+        primaryPattern = p.name;
+      }
+    }
+  }
+  return { patterns: result, primary_pattern: primaryPattern };
+}
+function detectServiceLayer(projectPath, ast) {
+  let score = 0;
+  const max = 5;
+  if (ast.services > 0) score += 2;
+  if (ast.services >= 3) score += 1;
+  if (existsSync7(join8(projectPath, "src", "services")) || existsSync7(join8(projectPath, "services"))) score += 1;
+  if (existsSync7(join8(projectPath, "src", "controllers")) || existsSync7(join8(projectPath, "controllers"))) score += 1;
+  return { name: "Service Layer", score, maxSignals: max };
+}
+function detectMvc(projectPath) {
+  let score = 0;
+  const max = 4;
+  const mvcDirs = ["models", "views", "controllers", "routes", "handlers"];
+  for (const dir of mvcDirs) {
+    if (existsSync7(join8(projectPath, "src", dir)) || existsSync7(join8(projectPath, dir))) {
+      score += 1;
+    }
+  }
+  return { name: "MVC", score: Math.min(score, max), maxSignals: max };
+}
+function detectEventDriven(ast) {
+  let score = 0;
+  const max = 4;
+  const eventPackages = ["events", "eventemitter", "amqplib", "kafkajs", "bullmq", "ioredis", "socket.io"];
+  for (const pkg of eventPackages) {
+    if (ast.imports_used.some((i) => i.includes(pkg))) score += 1;
+  }
+  if (ast.advanced_features.includes("async-await")) score += 0.5;
+  return { name: "Event-Driven", score: Math.min(score, max), maxSignals: max };
+}
+function detectRepositoryPattern(ast) {
+  let score = 0;
+  const max = 4;
+  if (ast.services > 0) score += 1;
+  if (ast.imports_used.some((i) => ["prisma", "@prisma/client", "typeorm", "sequelize", "drizzle-orm", "mongoose"].includes(i))) {
+    score += 2;
+  }
+  if (ast.imports_used.some((i) => ["@supabase/supabase-js", "firebase"].includes(i))) {
+    score += 1;
+  }
+  return { name: "Repository", score, maxSignals: max };
+}
+function detectMicroservices(projectPath) {
+  let score = 0;
+  const max = 4;
+  if (existsSync7(join8(projectPath, "docker-compose.yml")) || existsSync7(join8(projectPath, "docker-compose.yaml"))) {
+    score += 2;
+  }
+  if (existsSync7(join8(projectPath, "Dockerfile"))) score += 1;
+  if (existsSync7(join8(projectPath, "k8s")) || existsSync7(join8(projectPath, "kubernetes"))) score += 1;
+  return { name: "Microservices", score, maxSignals: max };
+}
+function detectMonorepo(projectPath) {
+  let score = 0;
+  const max = 4;
+  if (existsSync7(join8(projectPath, "turbo.json"))) score += 2;
+  if (existsSync7(join8(projectPath, "lerna.json"))) score += 2;
+  if (existsSync7(join8(projectPath, "pnpm-workspace.yaml"))) score += 2;
+  if (existsSync7(join8(projectPath, "packages"))) score += 1;
+  if (existsSync7(join8(projectPath, "apps"))) score += 1;
+  return { name: "Monorepo", score: Math.min(score, max), maxSignals: max };
+}
+function detectApiFirst(projectPath, fileDiscovery) {
+  let score = 0;
+  const max = 4;
+  const apiFiles = ["openapi.yml", "openapi.yaml", "openapi.json", "swagger.yml", "swagger.yaml", "swagger.json"];
+  for (const file of apiFiles) {
+    if (existsSync7(join8(projectPath, file))) {
+      score += 2;
+      break;
+    }
+  }
+  if (existsSync7(join8(projectPath, "src", "routes")) || existsSync7(join8(projectPath, "routes"))) score += 1;
+  if (existsSync7(join8(projectPath, "src", "api")) || existsSync7(join8(projectPath, "api"))) score += 1;
+  return { name: "API-First", score, maxSignals: max };
+}
+
+// src/layers/llm-classification.ts
+var SYSTEM_PROMPT2 = `You classify software projects based on analysis data.
+Return JSON only, no markdown fences. Schema:
+{
+  "domain": "string (e.g., travel-tech, fintech, e-commerce, dev-tools)",
+  "builder_profile": "string (e.g., engineer, PM-who-codes, builder, designer-who-ships)",
+  "role_signals": ["string array of matching roles"],
+  "is_end_to_end": boolean,
+  "description": "1-2 sentence project description"
+}`;
+async function classifyWithLlm(fileDiscovery, dependencies, astAnalysis, gitForensics, qualitySignals, architecturePatterns) {
+  if (!isApiKeyConfigured()) return null;
+  const topLanguages = Object.entries(fileDiscovery.languages).sort((a, b) => b[1].loc - a[1].loc).slice(0, 5).map(([lang, stats]) => `${lang} (${stats.loc.toLocaleString()} LOC)`).join(", ");
+  const patternStr = Object.entries(architecturePatterns.patterns).map(([name, conf]) => `${name} (${conf})`).join(", ") || "none detected";
+  const prompt = `Given this project analysis summary:
+  Languages: ${topLanguages}
+  Frameworks: ${dependencies.frameworks.join(", ") || "none"}
+  Structure: ${astAnalysis.functions} functions, ${astAnalysis.classes} classes, ${astAnalysis.components} components, ${astAnalysis.hooks} custom hooks
+  Git: ${gitForensics.commits} commits, ${gitForensics.active_days} active days, ${gitForensics.contributors} contributors
+  Quality: test ratio ${qualitySignals.test_ratio}, complexity ${qualitySignals.complexity_avg}, type safety: ${qualitySignals.type_safety}
+  Patterns: ${patternStr}
+  Imports: ${astAnalysis.imports_used.slice(0, 20).join(", ")}
+
+Classify this project:
+  1. Project domain
+  2. Builder profile
+  3. Role signals (what roles does this work suggest?)
+  4. End-to-end ownership? (single person across frontend+backend+infra?)
+  5. Brief project description (1-2 sentences)`;
+  try {
+    const response = await callHaiku(SYSTEM_PROMPT2, prompt);
+    const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    return {
+      domain: parsed.domain || "general",
+      builder_profile: parsed.builder_profile || "engineer",
+      role_signals: parsed.role_signals || [],
+      is_end_to_end: parsed.is_end_to_end || false,
+      description: parsed.description || ""
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/scan.ts
+async function scanCommand(path) {
+  const projectPath = resolve2(path);
+  const projectName = basename(projectPath);
+  if (!existsSync8(projectPath)) {
+    error(`Directory not found: ${projectPath}`);
+    process.exit(1);
+  }
+  header(`
+  Scanning ${projectName}...
+`);
+  start("Layer 1: File discovery...");
+  const fileDiscovery = await analyzeFileDiscovery(projectPath);
+  succeed("Layer 1: File discovery");
+  layerOutput(
+    "Layer 1: File discovery",
+    `${fileDiscovery.total_files} files, ${fileDiscovery.total_loc.toLocaleString()} LOC`
+  );
+  start("Layer 2: Dependencies...");
+  const dependencies = await analyzeDependencies(projectPath);
+  succeed("Layer 2: Dependencies");
+  layerOutput(
+    "Layer 2: Dependencies",
+    dependencies.frameworks.length > 0 ? dependencies.frameworks.join(", ") : dependencies.dependencies.slice(0, 5).join(", ") || "none detected"
+  );
+  start("Layer 3: AST analysis...");
+  const astAnalysis = await analyzeAst(projectPath, fileDiscovery.languages);
+  succeed("Layer 3: AST analysis");
+  layerOutput(
+    "Layer 3: AST analysis",
+    `${astAnalysis.functions} functions, ${astAnalysis.classes} classes, ${astAnalysis.components} components, ${astAnalysis.hooks} hooks`
+  );
+  start("Layer 4: Git forensics...");
+  const gitForensics = await analyzeGitForensics(projectPath);
+  succeed("Layer 4: Git forensics");
+  if (gitForensics.is_git_repo) {
+    layerOutput(
+      "Layer 4: Git forensics",
+      `${gitForensics.commits} commits, ${gitForensics.active_days} active days, ${gitForensics.contributors} contributors`
+    );
+  } else {
+    layerOutput("Layer 4: Git forensics", "Not a git repo");
+  }
+  start("Layer 5: Quality signals...");
+  const qualitySignals = await analyzeQualitySignals(projectPath, fileDiscovery);
+  succeed("Layer 5: Quality signals");
+  layerOutput(
+    "Layer 5: Quality signals",
+    `test ratio ${qualitySignals.test_ratio}, complexity ${qualitySignals.complexity_avg}, ${qualitySignals.type_safety ? "strict TS" : "no strict types"}`
+  );
+  start("Layer 6: Architecture patterns...");
+  const architecturePatterns = await analyzeArchitecturePatterns(projectPath, fileDiscovery, astAnalysis);
+  succeed("Layer 6: Architecture patterns");
+  const patternStr = Object.entries(architecturePatterns.patterns).map(([name, conf]) => `${name} (${conf})`).join(", ") || "none detected";
+  layerOutput("Layer 6: Architecture patterns", patternStr);
+  let llmClassification = null;
+  if (isApiKeyConfigured()) {
+    start("Layer 7: LLM classification (API call)...");
+    llmClassification = await classifyWithLlm(
+      fileDiscovery,
+      dependencies,
+      astAnalysis,
+      gitForensics,
+      qualitySignals,
+      architecturePatterns
+    );
+    if (llmClassification) {
+      succeed("Layer 7: LLM classification");
+      layerOutput(
+        "Layer 7: LLM classification",
+        `${llmClassification.domain}, ${llmClassification.builder_profile}`
+      );
+    } else {
+      fail("Layer 7: LLM classification failed");
+    }
+  } else {
+    dim("  Layer 7: Skipped (no API key \u2014 run inside Claude Code for full analysis)");
+  }
+  const scanResult = {
+    project_name: projectName,
+    project_path: projectPath,
+    file_discovery: fileDiscovery,
+    dependencies,
+    ast_analysis: astAnalysis,
+    git_forensics: gitForensics,
+    quality_signals: qualitySignals,
+    architecture_patterns: architecturePatterns,
+    llm_classification: llmClassification
+  };
+  start("Updating skill graph...");
+  let graph = await loadGraph();
+  if (!graph) {
+    graph = createEmptySkillGraph({
+      name: "",
+      email: "",
+      primary_role: "engineer",
+      target_roles: [],
+      previous_companies: [],
+      education: [],
+      links: {},
+      source: "manual"
+    });
+  }
+  const projectEntry = buildProjectEntry(scanResult);
+  graph = mergeIntoGraph(graph, projectEntry, llmClassification);
+  await saveGraph(graph);
+  succeed("Skill graph updated");
+  success(`
+Scan complete. ${graph.projects.length} project(s) in skill graph.`);
+  info("Run `hiregraph status` to see your full profile.");
+}
+
+// src/commands/status.ts
+import chalk2 from "chalk";
+async function statusCommand() {
+  const graph = await loadGraph();
+  if (!graph || graph.projects.length === 0) {
+    warn("No skill graph found.");
+    info("Run `hiregraph init` to set up your profile.");
+    info("Run `hiregraph scan <path>` to analyze a project.");
+    return;
+  }
+  const identity = graph.builder_identity;
+  header("\n  HireGraph Status\n");
+  if (identity.name) {
+    console.log(`  ${chalk2.bold("Builder:")} ${identity.name} (${identity.primary_role})`);
+  }
+  console.log(`  ${chalk2.bold("Projects scanned:")} ${graph.projects.length}`);
+  console.log();
+  const skills = Object.entries(graph.tech_stack).sort((a, b) => b[1].proficiency - a[1].proficiency).slice(0, 10);
+  if (skills.length > 0) {
+    console.log(`  ${chalk2.bold("Tech Stack:")}`);
+    const maxNameLen = Math.max(...skills.map(([name]) => name.length));
+    for (const [name, skill] of skills) {
+      const bar = renderBar(skill.proficiency, 20);
+      const locStr = skill.loc > 0 ? `${skill.loc.toLocaleString()} LOC` : "";
+      const projStr = skill.projects > 0 ? `${skill.projects} projects` : "";
+      const details = [locStr, projStr].filter(Boolean).join(", ");
+      console.log(`    ${name.padEnd(maxNameLen + 2)} ${bar}  ${skill.proficiency.toFixed(2)}${details ? `  (${details})` : ""}`);
+    }
+    console.log();
+  }
+  const patterns = Object.entries(graph.architecture).sort((a, b) => b[1].confidence - a[1].confidence);
+  if (patterns.length > 0) {
+    const patternStr = patterns.map(([name, { confidence }]) => `${name} (${confidence})`).join(", ");
+    console.log(`  ${chalk2.bold("Architecture:")} ${patternStr}`);
+  }
+  console.log(`  ${chalk2.bold("Quality:")} test ratio ${graph.quality.test_ratio}, complexity ${graph.quality.complexity_avg}${graph.quality.type_safety ? ", strict types" : ""}`);
+  if (graph.builder_profile.role_signals.length > 0) {
+    console.log(`  ${chalk2.bold("Role Signals:")} ${graph.builder_profile.role_signals.join(", ")}`);
+  }
+  if (graph.builder_profile.is_end_to_end) {
+    console.log(`  ${chalk2.bold("Builder Profile:")} End-to-end ownership detected`);
+  }
+  console.log();
+  console.log(`  ${chalk2.bold("Projects:")}`);
+  for (const project of graph.projects) {
+    const age = getTimeAgo(project.scanned_at);
+    console.log(`    ${chalk2.cyan(project.name)} \u2014 ${project.domain || "unknown domain"} (scanned ${age})`);
+    const stackStr = project.stack.slice(0, 5).join(", ");
+    if (stackStr) console.log(`      ${chalk2.dim(stackStr)}`);
+  }
+  console.log();
+  dim(`  Last updated: ${getTimeAgo(graph.last_updated)}`);
+  console.log();
+}
+function renderBar(value, width) {
+  const filled = Math.round(value * width);
+  const empty = width - filled;
+  return chalk2.green("\u2588".repeat(filled)) + chalk2.dim("\u2591".repeat(empty));
+}
+function getTimeAgo(isoDate) {
+  const diff = Date.now() - new Date(isoDate).getTime();
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// src/commands/jobs.ts
+import chalk3 from "chalk";
+
+// src/ats/registry.ts
+import { readFile as readFile8 } from "fs/promises";
+import { join as join9, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync9 } from "fs";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+async function loadRegistry() {
+  const candidates = [
+    join9(__dirname, "..", "data", "companies.json"),
+    join9(__dirname, "..", "..", "src", "data", "companies.json"),
+    join9(__dirname, "data", "companies.json")
+  ];
+  let companies = [];
+  for (const seedPath of candidates) {
+    if (existsSync9(seedPath)) {
+      const raw = await readFile8(seedPath, "utf-8");
+      companies = JSON.parse(raw);
+      break;
+    }
+  }
+  const userCompanies = await loadJson("companies.json");
+  if (userCompanies) {
+    const bySlug = new Map(companies.map((c) => [c.slug, c]));
+    for (const uc of userCompanies) {
+      bySlug.set(uc.slug, uc);
+    }
+    companies = [...bySlug.values()];
+  }
+  return companies;
+}
+function filterByAts(companies, ats) {
+  return companies.filter((c) => c.ats === ats);
+}
+function excludeCompanies(companies, slugs) {
+  const excluded = new Set(slugs);
+  return companies.filter((c) => !excluded.has(c.slug));
+}
+
+// src/ats/greenhouse.ts
+async function fetchGreenhouseJobs(boardToken) {
+  const url = `https://boards-api.greenhouse.io/v1/boards/${boardToken}/jobs?content=true`;
+  const response = await fetch(url, {
+    headers: { "Accept": "application/json" },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    if (response.status === 429) throw new Error("Rate limited");
+    throw new Error(`HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  return data.jobs || [];
+}
+
+// src/ats/lever.ts
+async function fetchLeverPostings(company) {
+  const url = `https://api.lever.co/v0/postings/${company}`;
+  const response = await fetch(url, {
+    headers: { "Accept": "application/json" },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    if (response.status === 429) throw new Error("Rate limited");
+    throw new Error(`HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  return Array.isArray(data) ? data : [];
+}
+
+// src/ats/ashby.ts
+async function fetchAshbyJobs(boardId) {
+  const url = `https://api.ashbyhq.com/posting-api/job-board/${boardId}`;
+  const response = await fetch(url, {
+    headers: { "Accept": "application/json" },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    if (response.status === 429) throw new Error("Rate limited");
+    throw new Error(`HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  return data.jobs || [];
+}
+
+// src/ats/normalizer.ts
+function stripHtml(html) {
+  return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<\/li>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function normalizeGreenhouseJob(raw, company) {
+  return {
+    id: `gh_${raw.id}`,
+    source: "greenhouse",
+    company: company.name,
+    company_slug: company.slug,
+    title: raw.title,
+    url: raw.absolute_url,
+    location: raw.location?.name || "Unknown",
+    department: raw.departments?.[0]?.name,
+    description_raw: stripHtml(raw.content || ""),
+    updated_at: raw.updated_at,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeLeverPosting(raw, company) {
+  const descParts = [raw.descriptionPlain || stripHtml(raw.description || "")];
+  if (raw.lists) {
+    for (const list of raw.lists) {
+      descParts.push(`${list.text}
+${stripHtml(list.content)}`);
+    }
+  }
+  return {
+    id: `lv_${raw.id}`,
+    source: "lever",
+    company: company.name,
+    company_slug: company.slug,
+    title: raw.text,
+    url: raw.hostedUrl,
+    location: raw.categories?.location || "Unknown",
+    department: raw.categories?.department || raw.categories?.team,
+    description_raw: descParts.join("\n\n"),
+    posted_at: raw.createdAt ? new Date(raw.createdAt).toISOString() : void 0,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeAshbyJob(raw, company) {
+  return {
+    id: `ab_${raw.id}`,
+    source: "ashby",
+    company: company.name,
+    company_slug: company.slug,
+    title: raw.title,
+    url: raw.jobUrl || `https://jobs.ashbyhq.com/${company.board_token}/${raw.id}`,
+    location: raw.location || "Unknown",
+    department: raw.department,
+    description_raw: stripHtml(raw.descriptionHtml || ""),
+    posted_at: raw.publishedAt,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/ats/fetcher.ts
+var CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var BATCH_SIZE = 5;
+var BATCH_DELAY_MS = 500;
+function isCacheStale(fetchedAt) {
+  return Date.now() - new Date(fetchedAt).getTime() > CACHE_MAX_AGE_MS;
+}
+async function delay(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+async function fetchInBatches(items, fn, getName, errors) {
+  const allJobs = [];
+  for (let i = 0; i < items.length; i += BATCH_SIZE) {
+    const batch = items.slice(i, i + BATCH_SIZE);
+    const results = await Promise.allSettled(batch.map((item) => fn(item)));
+    for (let j = 0; j < results.length; j++) {
+      const result = results[j];
+      if (result.status === "fulfilled") {
+        allJobs.push(...result.value);
+      } else {
+        errors.push({ company: getName(batch[j]), error: result.reason?.message || "Unknown error" });
+      }
+    }
+    if (i + BATCH_SIZE < items.length) {
+      await delay(BATCH_DELAY_MS);
+    }
+  }
+  return allJobs;
+}
+async function fetchAllJobs(options) {
+  const config = await loadJson("config.json");
+  let companies = await loadRegistry();
+  companies = excludeCompanies(companies, config?.excluded_companies || []);
+  if (options?.ats) {
+    companies = filterByAts(companies, options.ats);
+  }
+  const errors = [];
+  const allJobs = [];
+  const stats = { greenhouse: 0, lever: 0, ashby: 0, total: 0, failed: 0 };
+  const ghCompanies = companies.filter((c) => c.ats === "greenhouse");
+  if (ghCompanies.length > 0) {
+    const cached = await loadSubJson("jobs", "greenhouse.json");
+    if (cached && !isCacheStale(cached.fetched_at) && !options?.refresh) {
+      allJobs.push(...cached.jobs);
+      stats.greenhouse = cached.total_jobs;
+    } else {
+      start(`Fetching from Greenhouse (${ghCompanies.length} companies)...`);
+      const ghJobs = await fetchInBatches(
+        ghCompanies,
+        async (c) => {
+          const raw = await fetchGreenhouseJobs(c.board_token);
+          return raw.map((j) => normalizeGreenhouseJob(j, c));
+        },
+        (c) => c.name,
+        errors
+      );
+      allJobs.push(...ghJobs);
+      stats.greenhouse = ghJobs.length;
+      succeed(`Greenhouse: ${ghJobs.length} jobs from ${ghCompanies.length} companies`);
+      await saveSubJson("jobs", "greenhouse.json", {
+        source: "greenhouse",
+        fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+        companies_fetched: ghCompanies.length,
+        total_jobs: ghJobs.length,
+        jobs: ghJobs
+      });
+    }
+  }
+  const lvCompanies = companies.filter((c) => c.ats === "lever");
+  if (lvCompanies.length > 0) {
+    const cached = await loadSubJson("jobs", "lever.json");
+    if (cached && !isCacheStale(cached.fetched_at) && !options?.refresh) {
+      allJobs.push(...cached.jobs);
+      stats.lever = cached.total_jobs;
+    } else {
+      start(`Fetching from Lever (${lvCompanies.length} companies)...`);
+      const lvJobs = await fetchInBatches(
+        lvCompanies,
+        async (c) => {
+          const raw = await fetchLeverPostings(c.board_token);
+          return raw.map((j) => normalizeLeverPosting(j, c));
+        },
+        (c) => c.name,
+        errors
+      );
+      allJobs.push(...lvJobs);
+      stats.lever = lvJobs.length;
+      succeed(`Lever: ${lvJobs.length} jobs from ${lvCompanies.length} companies`);
+      await saveSubJson("jobs", "lever.json", {
+        source: "lever",
+        fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+        companies_fetched: lvCompanies.length,
+        total_jobs: lvJobs.length,
+        jobs: lvJobs
+      });
+    }
+  }
+  const abCompanies = companies.filter((c) => c.ats === "ashby");
+  if (abCompanies.length > 0) {
+    const cached = await loadSubJson("jobs", "ashby.json");
+    if (cached && !isCacheStale(cached.fetched_at) && !options?.refresh) {
+      allJobs.push(...cached.jobs);
+      stats.ashby = cached.total_jobs;
+    } else {
+      start(`Fetching from Ashby (${abCompanies.length} companies)...`);
+      const abJobs = await fetchInBatches(
+        abCompanies,
+        async (c) => {
+          const raw = await fetchAshbyJobs(c.board_token);
+          return raw.map((j) => normalizeAshbyJob(j, c));
+        },
+        (c) => c.name,
+        errors
+      );
+      allJobs.push(...abJobs);
+      stats.ashby = abJobs.length;
+      succeed(`Ashby: ${abJobs.length} jobs from ${abCompanies.length} companies`);
+      await saveSubJson("jobs", "ashby.json", {
+        source: "ashby",
+        fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+        companies_fetched: abCompanies.length,
+        total_jobs: abJobs.length,
+        jobs: abJobs
+      });
+    }
+  }
+  stats.total = allJobs.length;
+  stats.failed = errors.length;
+  return { jobs: allJobs, errors, stats };
+}
+
+// src/commands/jobs.ts
+async function jobsCommand(options) {
+  header("\n  HireGraph Jobs\n");
+  const companies = await loadRegistry();
+  const ghCount = companies.filter((c) => c.ats === "greenhouse").length;
+  const lvCount = companies.filter((c) => c.ats === "lever").length;
+  const abCount = companies.filter((c) => c.ats === "ashby").length;
+  info(`  Registry: ${companies.length} companies (${ghCount} Greenhouse, ${lvCount} Lever, ${abCount} Ashby)
+`);
+  const result = await fetchAllJobs({ refresh: options.refresh, ats: options.ats });
+  console.log();
+  console.log(`  ${chalk3.bold("Jobs Fetched:")}`);
+  if (result.stats.greenhouse > 0) {
+    console.log(`    Greenhouse    ${result.stats.greenhouse.toLocaleString().padStart(6)} jobs`);
+  }
+  if (result.stats.lever > 0) {
+    console.log(`    Lever         ${result.stats.lever.toLocaleString().padStart(6)} jobs`);
+  }
+  if (result.stats.ashby > 0) {
+    console.log(`    Ashby         ${result.stats.ashby.toLocaleString().padStart(6)} jobs`);
+  }
+  console.log(`    ${chalk3.bold("Total")}         ${chalk3.bold(result.stats.total.toLocaleString().padStart(6))} jobs`);
+  if (result.stats.failed > 0) {
+    console.log();
+    warn(`  ${result.stats.failed} companies unreachable:`);
+    for (const err of result.errors.slice(0, 10)) {
+      dim(`    ${err.company}: ${err.error}`);
+    }
+    if (result.errors.length > 10) {
+      dim(`    ... and ${result.errors.length - 10} more`);
+    }
+  }
+  if (options.limit && options.limit > 0) {
+    console.log();
+    console.log(`  ${chalk3.bold("Sample jobs:")}`);
+    const sample = result.jobs.slice(0, options.limit);
+    for (const job of sample) {
+      console.log(`    ${chalk3.cyan(job.title)} @ ${job.company} (${job.location})`);
+    }
+  }
+  console.log();
+  info("  Cached to ~/.hiregraph/jobs/");
+  info("  Run `hiregraph matches` to find your best matches.");
+  console.log();
+}
+
+// src/commands/matches.ts
+import chalk4 from "chalk";
+
+// src/matching/job-parser.ts
+var SYSTEM_PROMPT3 = `You extract structured job requirements from job descriptions.
+Return JSON only, no markdown fences. Schema:
+{
+  "must_have_skills": ["string array"],
+  "nice_to_have_skills": ["string array"],
+  "seniority_level": "junior|mid|senior|staff|principal|lead|manager",
+  "tech_stack": ["specific technologies mentioned"],
+  "domain": "string (e.g., fintech, dev-tools, e-commerce)",
+  "remote_policy": "remote|hybrid|onsite|unknown",
+  "compensation_range": { "min": number|null, "max": number|null, "currency": "USD" } | null
+}`;
+var BATCH_SIZE2 = 10;
+var BATCH_DELAY_MS2 = 1e3;
+async function parseJobsBatch(jobs) {
+  if (!isApiKeyConfigured()) {
+    throw new Error("No API key detected. Run hiregraph inside Claude Code or Cursor.");
+  }
+  const cached = await loadSubJson("jobs", "parsed.json");
+  const requirements = cached?.requirements || {};
+  const unparsed = jobs.filter((j) => !requirements[j.id]);
+  if (unparsed.length === 0) return requirements;
+  start(`Parsing ${unparsed.length} new job descriptions...`);
+  let parsed = 0;
+  for (let i = 0; i < unparsed.length; i += BATCH_SIZE2) {
+    const batch = unparsed.slice(i, i + BATCH_SIZE2);
+    const results = await Promise.allSettled(
+      batch.map((job) => parseOneJob(job))
+    );
+    for (let j = 0; j < results.length; j++) {
+      if (results[j].status === "fulfilled") {
+        const req = results[j].value;
+        requirements[batch[j].id] = req;
+        parsed++;
+      }
+    }
+    if (i + BATCH_SIZE2 < unparsed.length) {
+      await new Promise((r) => setTimeout(r, BATCH_DELAY_MS2));
+    }
+  }
+  succeed(`Parsed ${parsed} job descriptions (${Object.keys(requirements).length} total cached)`);
+  await saveSubJson("jobs", "parsed.json", {
+    parsed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    requirements
+  });
+  return requirements;
+}
+async function parseOneJob(job) {
+  const description = job.description_raw.slice(0, 4e3);
+  const result = await callHaikuJson(
+    SYSTEM_PROMPT3,
+    `Job: ${job.title} at ${job.company}
+Location: ${job.location}
+
+${description}`
+  );
+  return {
+    job_id: job.id,
+    must_have_skills: result.must_have_skills || [],
+    nice_to_have_skills: result.nice_to_have_skills || [],
+    seniority_level: result.seniority_level || "mid",
+    tech_stack: result.tech_stack || [],
+    domain: result.domain || "unknown",
+    remote_policy: result.remote_policy || "unknown",
+    compensation_range: result.compensation_range || void 0,
+    parsed_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/matching/vectorizer.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "can",
+  "shall",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "if",
+  "then",
+  "than",
+  "that",
+  "this",
+  "these",
+  "those",
+  "it",
+  "its",
+  "we",
+  "you",
+  "he",
+  "she",
+  "they",
+  "our",
+  "your",
+  "their",
+  "who",
+  "which",
+  "what",
+  "where",
+  "when",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "only",
+  "very",
+  "also",
+  "just",
+  "about",
+  "up",
+  "out",
+  "as",
+  "into",
+  "through",
+  "over",
+  "after",
+  "before",
+  "between",
+  "under",
+  "above",
+  "while",
+  "during",
+  "experience",
+  "work",
+  "working",
+  "ability",
+  "strong",
+  "team",
+  "role",
+  "position",
+  "company",
+  "using",
+  "used",
+  "use",
+  "years",
+  "year"
+]);
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9.#+\-_/]/g, " ").split(/\s+/).filter((t) => t.length > 1 && !STOP_WORDS.has(t));
+}
+function buildVocabulary(documents) {
+  const docFreq = /* @__PURE__ */ new Map();
+  const allTerms = /* @__PURE__ */ new Set();
+  for (const doc of documents) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const term of doc) {
+      allTerms.add(term);
+      if (!seen.has(term)) {
+        seen.add(term);
+        docFreq.set(term, (docFreq.get(term) || 0) + 1);
+      }
+    }
+  }
+  const sorted = [...allTerms].filter((t) => (docFreq.get(t) || 0) >= 2).sort((a, b) => (docFreq.get(b) || 0) - (docFreq.get(a) || 0)).slice(0, 2e3);
+  const termToIndex = /* @__PURE__ */ new Map();
+  const idf = new Float32Array(sorted.length);
+  const N = documents.length;
+  for (let i = 0; i < sorted.length; i++) {
+    termToIndex.set(sorted[i], i);
+    const df = docFreq.get(sorted[i]) || 1;
+    idf[i] = Math.log(N / df) + 1;
+  }
+  return { termToIndex, idf, size: sorted.length };
+}
+function vectorize(tokens, vocab) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const idx = vocab.termToIndex.get(token);
+    if (idx !== void 0) {
+      tf.set(idx, (tf.get(idx) || 0) + 1);
+    }
+  }
+  const terms = /* @__PURE__ */ new Map();
+  let magnitude = 0;
+  for (const [idx, count] of tf) {
+    const weight = count * vocab.idf[idx];
+    terms.set(idx, weight);
+    magnitude += weight * weight;
+  }
+  magnitude = Math.sqrt(magnitude);
+  return { terms, magnitude };
+}
+function buildSkillVector(graph, vocab) {
+  const tokens = [];
+  for (const [skill, data] of Object.entries(graph.tech_stack)) {
+    const name = skill.toLowerCase();
+    const repeat = data.proficiency > 0.5 ? 3 : data.proficiency > 0.3 ? 2 : 1;
+    for (let i = 0; i < repeat; i++) {
+      tokens.push(...tokenize(name));
+    }
+  }
+  for (const [pattern] of Object.entries(graph.architecture)) {
+    tokens.push(...tokenize(pattern));
+  }
+  for (const signal of graph.builder_profile.role_signals) {
+    tokens.push(...tokenize(signal));
+  }
+  for (const proj of graph.projects) {
+    if (proj.domain) tokens.push(...tokenize(proj.domain));
+    for (const s of proj.stack) tokens.push(...tokenize(s));
+  }
+  return vectorize(tokens, vocab);
+}
+function buildJobVector(req, vocab) {
+  const tokens = [];
+  for (const skill of req.must_have_skills) {
+    const t = tokenize(skill);
+    tokens.push(...t, ...t);
+  }
+  for (const skill of req.nice_to_have_skills) {
+    tokens.push(...tokenize(skill));
+  }
+  for (const tech of req.tech_stack) {
+    tokens.push(...tokenize(tech));
+  }
+  if (req.domain) tokens.push(...tokenize(req.domain));
+  return vectorize(tokens, vocab);
+}
+function cosineSimilarity(a, b) {
+  if (a.magnitude === 0 || b.magnitude === 0) return 0;
+  let dotProduct = 0;
+  const [smaller, larger] = a.terms.size <= b.terms.size ? [a, b] : [b, a];
+  for (const [idx, weight] of smaller.terms) {
+    const otherWeight = larger.terms.get(idx);
+    if (otherWeight !== void 0) {
+      dotProduct += weight * otherWeight;
+    }
+  }
+  return dotProduct / (a.magnitude * b.magnitude);
+}
+function buildAllDocuments(graph, requirements) {
+  const docs = [];
+  const skillTokens = [];
+  for (const skill of Object.keys(graph.tech_stack)) {
+    skillTokens.push(...tokenize(skill));
+  }
+  for (const proj of graph.projects) {
+    for (const s of proj.stack) skillTokens.push(...tokenize(s));
+    if (proj.domain) skillTokens.push(...tokenize(proj.domain));
+  }
+  docs.push(skillTokens);
+  for (const req of Object.values(requirements)) {
+    const tokens = [];
+    for (const s of req.must_have_skills) tokens.push(...tokenize(s));
+    for (const s of req.nice_to_have_skills) tokens.push(...tokenize(s));
+    for (const s of req.tech_stack) tokens.push(...tokenize(s));
+    if (req.domain) tokens.push(...tokenize(req.domain));
+    docs.push(tokens);
+  }
+  return docs;
+}
+
+// src/matching/similarity.ts
+function findTopCandidates(skillVector, jobVectors, k) {
+  const scored = [];
+  for (const [jobId, jobVector] of jobVectors) {
+    const sim = cosineSimilarity(skillVector, jobVector);
+    if (sim > 0) {
+      scored.push({ jobId, similarity: sim });
+    }
+  }
+  scored.sort((a, b) => b.similarity - a.similarity);
+  return scored.slice(0, k);
+}
+
+// src/matching/filters.ts
+function applyHardFilters(jobs, config) {
+  const excluded = new Set(config.excluded_companies.map((s) => s.toLowerCase()));
+  return jobs.filter(({ job, requirements }) => {
+    if (excluded.has(job.company_slug.toLowerCase())) return false;
+    if (config.remote_preference === "Remote" && requirements.remote_policy === "onsite") {
+      return false;
+    }
+    if (config.min_compensation && requirements.compensation_range?.max) {
+      const min = parseCompensation(config.min_compensation);
+      if (min > 0 && requirements.compensation_range.max < min) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function parseCompensation(value) {
+  const cleaned = value.replace(/[$,]/g, "").trim();
+  if (cleaned.toLowerCase().endsWith("k")) {
+    return parseFloat(cleaned) * 1e3;
+  }
+  return parseFloat(cleaned) || 0;
+}
+
+// src/matching/evaluator.ts
+var SYSTEM_PROMPT4 = `You evaluate job-candidate match quality. Given a candidate's verified skill profile and a job's requirements, score the match.
+
+Rules:
+- code-verified skills are confirmed facts. Weight heavily.
+- self-reported skills are unverified claims. Weight lower.
+- Proficiency scores: 0.8+ is strong, 0.5+ is moderate, below 0.3 is beginner.
+- For 'builder' profiles, value end-to-end ownership over single-area depth.
+- Be strict. 7/10 = genuinely strong match. 8+ = exceptional fit.
+
+Return JSON only, no markdown fences. Schema:
+{
+  "score": number (1-10),
+  "confidence": number (0.0-1.0),
+  "reasoning": "2-3 sentences explaining the match",
+  "strengths": ["key matching strengths"],
+  "gaps": ["notable gaps or missing skills"]
+}`;
+var BATCH_SIZE3 = 5;
+var BATCH_DELAY_MS3 = 1500;
+async function evaluateMatchesBatch(candidates, graph) {
+  if (!isApiKeyConfigured()) {
+    throw new Error("No API key detected. Run hiregraph inside Claude Code or Cursor.");
+  }
+  const skillSummary = buildSkillSummary(graph);
+  const results = [];
+  start(`Evaluating ${candidates.length} matches with LLM...`);
+  for (let i = 0; i < candidates.length; i += BATCH_SIZE3) {
+    const batch = candidates.slice(i, i + BATCH_SIZE3);
+    const batchResults = await Promise.allSettled(
+      batch.map(({ job, requirements }) => evaluateOne(skillSummary, job, requirements))
+    );
+    for (let j = 0; j < batchResults.length; j++) {
+      if (batchResults[j].status === "fulfilled") {
+        results.push(batchResults[j].value);
+      }
+    }
+    if (i + BATCH_SIZE3 < candidates.length) {
+      await new Promise((r) => setTimeout(r, BATCH_DELAY_MS3));
+    }
+  }
+  succeed(`Evaluated ${results.length} matches`);
+  return results;
+}
+async function evaluateOne(skillSummary, job, requirements) {
+  const jobSummary = buildJobSummary(job, requirements);
+  const prompt = `CANDIDATE PROFILE:
+${skillSummary}
+
+JOB:
+${jobSummary}`;
+  const result = await callHaikuJson(SYSTEM_PROMPT4, prompt, 2048);
+  const score = Math.min(10, Math.max(1, result.score || 1));
+  const tier = score >= 8 ? "strong" : score >= 6 ? "suggested" : "filtered";
+  return {
+    job_id: job.id,
+    job_title: job.title,
+    company: job.company,
+    company_slug: job.company_slug,
+    url: job.url,
+    score,
+    confidence: result.confidence || 0.5,
+    tier,
+    reasoning: result.reasoning || "",
+    strengths: result.strengths || [],
+    gaps: result.gaps || [],
+    matched_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildSkillSummary(graph) {
+  const lines = [];
+  if (graph.builder_identity.name) {
+    lines.push(`Name: ${graph.builder_identity.name} (${graph.builder_identity.primary_role})`);
+  }
+  const skills = Object.entries(graph.tech_stack).sort((a, b) => b[1].proficiency - a[1].proficiency).slice(0, 15);
+  if (skills.length > 0) {
+    lines.push("Tech Stack (code-verified):");
+    for (const [name, data] of skills) {
+      lines.push(`  ${name}: proficiency ${data.proficiency}, ${data.loc.toLocaleString()} LOC, ${data.projects} projects`);
+    }
+  }
+  const patterns = Object.entries(graph.architecture).sort((a, b) => b[1].confidence - a[1].confidence);
+  if (patterns.length > 0) {
+    lines.push(`Architecture: ${patterns.map(([n, { confidence }]) => `${n} (${confidence})`).join(", ")}`);
+  }
+  lines.push(`Quality: test ratio ${graph.quality.test_ratio}, complexity ${graph.quality.complexity_avg}`);
+  if (graph.projects.length > 0) {
+    lines.push(`Projects (${graph.projects.length}):`);
+    for (const proj of graph.projects.slice(0, 5)) {
+      lines.push(`  ${proj.name}: ${proj.domain || "unknown"} \u2014 ${proj.stack.slice(0, 5).join(", ")}`);
+    }
+  }
+  if (graph.builder_profile.role_signals.length > 0) {
+    lines.push(`Role signals: ${graph.builder_profile.role_signals.join(", ")}`);
+  }
+  if (graph.builder_profile.is_end_to_end) {
+    lines.push("End-to-end builder: yes");
+  }
+  if (graph.builder_identity.previous_companies.length > 0) {
+    lines.push("Work history:");
+    for (const w of graph.builder_identity.previous_companies) {
+      lines.push(`  ${w.role} @ ${w.company} (${w.start_year}-${w.end_year || "present"})`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildJobSummary(job, req) {
+  const lines = [
+    `Title: ${job.title}`,
+    `Company: ${job.company}`,
+    `Location: ${job.location}`,
+    `Seniority: ${req.seniority_level}`,
+    `Domain: ${req.domain}`,
+    `Remote: ${req.remote_policy}`
+  ];
+  if (req.must_have_skills.length > 0) {
+    lines.push(`Must have: ${req.must_have_skills.join(", ")}`);
+  }
+  if (req.nice_to_have_skills.length > 0) {
+    lines.push(`Nice to have: ${req.nice_to_have_skills.join(", ")}`);
+  }
+  if (req.tech_stack.length > 0) {
+    lines.push(`Tech stack: ${req.tech_stack.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/matching/matcher.ts
+async function runMatchPipeline(options) {
+  const topK = options?.topK || 50;
+  const maxEval = options?.maxEval || 50;
+  const graph = await loadGraph();
+  if (!graph || graph.projects.length === 0) {
+    throw new Error("No skill graph found. Run `hiregraph scan <path>` first.");
+  }
+  const identity = graph.builder_identity;
+  const config = await loadJson("config.json");
+  const filterConfig = {
+    excluded_companies: config?.excluded_companies || [],
+    remote_preference: identity.remote_preference,
+    min_compensation: identity.min_compensation
+  };
+  const fetchResult = await fetchAllJobs({ refresh: options?.refresh });
+  const allJobs = fetchResult.jobs;
+  if (allJobs.length === 0) {
+    throw new Error("No jobs found. Run `hiregraph jobs` first.");
+  }
+  const requirements = await parseJobsBatch(allJobs);
+  const jobMap = /* @__PURE__ */ new Map();
+  for (const job of allJobs) jobMap.set(job.id, job);
+  const filterableJobs = [];
+  for (const [jobId, req] of Object.entries(requirements)) {
+    const job = jobMap.get(jobId);
+    if (job) filterableJobs.push({ job, requirements: req });
+  }
+  start("Applying filters...");
+  const filtered = applyHardFilters(filterableJobs, filterConfig);
+  succeed(`After filtering: ${filtered.length} jobs (from ${filterableJobs.length})`);
+  if (filtered.length === 0) {
+    throw new Error("All jobs filtered out. Try adjusting your preferences.");
+  }
+  start("Building vectors for matching...");
+  const filteredReqs = {};
+  for (const f of filtered) filteredReqs[f.job.id] = f.requirements;
+  const documents = buildAllDocuments(graph, filteredReqs);
+  const vocab = buildVocabulary(documents);
+  const skillVector = buildSkillVector(graph, vocab);
+  const jobVectors = /* @__PURE__ */ new Map();
+  for (const f of filtered) {
+    jobVectors.set(f.job.id, buildJobVector(f.requirements, vocab));
+  }
+  succeed(`Vectorized ${filtered.length} jobs`);
+  start(`Pre-filtering top ${topK} candidates...`);
+  const candidates = findTopCandidates(skillVector, jobVectors, topK);
+  succeed(`Top ${candidates.length} candidates selected`);
+  const evalInputs = candidates.slice(0, maxEval).map((c) => {
+    const job = jobMap.get(c.jobId);
+    const req = requirements[c.jobId];
+    return { job, requirements: req };
+  });
+  const matchResults = await evaluateMatchesBatch(evalInputs, graph);
+  matchResults.sort((a, b) => b.score - a.score);
+  const strong = matchResults.filter((m) => m.tier === "strong");
+  const suggested = matchResults.filter((m) => m.tier === "suggested");
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const matchRun = {
+    date: today,
+    total_jobs_fetched: allJobs.length,
+    total_jobs_parsed: Object.keys(requirements).length,
+    total_candidates_evaluated: matchResults.length,
+    strong_matches: strong,
+    suggested_matches: suggested,
+    run_at: (/* @__PURE__ */ new Date()).toISOString(),
+    cost_estimate: {
+      jobs_parsed: Object.keys(requirements).length,
+      pairs_evaluated: matchResults.length,
+      estimated_usd: Math.round((Object.keys(requirements).length * 3e-4 + matchResults.length * 3e-3) * 100) / 100
+    }
+  };
+  await saveSubJson("matches", `${today}.json`, matchRun);
+  return matchRun;
+}
+
+// src/commands/matches.ts
+async function matchesCommand(options) {
+  header("\n  HireGraph Matches\n");
+  if (!isApiKeyConfigured()) {
+    warn("No API key detected. Run hiregraph inside Claude Code or Cursor for automatic access.");
+    return;
+  }
+  try {
+    const result = await runMatchPipeline({
+      topK: options.top || 50,
+      refresh: options.refresh
+    });
+    console.log();
+    if (result.strong_matches.length > 0) {
+      console.log(`  ${chalk4.bold.green("Strong Matches (score 8-10):")}`);
+      for (let i = 0; i < result.strong_matches.length; i++) {
+        printMatch(result.strong_matches[i], i + 1, true);
+      }
+      console.log();
+    }
+    if (result.suggested_matches.length > 0) {
+      console.log(`  ${chalk4.bold.yellow("Suggested Matches (score 6-7):")}`);
+      for (let i = 0; i < result.suggested_matches.length; i++) {
+        const idx = result.strong_matches.length + i + 1;
+        printMatch(result.suggested_matches[i], idx, !!options.verbose);
+      }
+      console.log();
+    }
+    if (result.strong_matches.length === 0 && result.suggested_matches.length === 0) {
+      warn("  No matches above threshold. Try scanning more projects or adjusting preferences.");
+      console.log();
+    }
+    console.log(`  ${chalk4.bold("Summary:")}`);
+    console.log(`    Jobs analyzed:     ${result.total_jobs_fetched.toLocaleString()}`);
+    console.log(`    Jobs parsed:       ${result.total_jobs_parsed.toLocaleString()}`);
+    console.log(`    LLM evaluated:     ${result.total_candidates_evaluated}`);
+    console.log(`    Strong matches:    ${chalk4.green(String(result.strong_matches.length))}`);
+    console.log(`    Suggested:         ${chalk4.yellow(String(result.suggested_matches.length))}`);
+    console.log(`    Cost estimate:     ~$${result.cost_estimate.estimated_usd.toFixed(2)}`);
+    console.log();
+    info(`  Results saved to ~/.hiregraph/matches/${result.date}.json`);
+    console.log();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+function printMatch(match, rank, showDetails) {
+  const scoreColor = match.score >= 8 ? chalk4.green : chalk4.yellow;
+  console.log(`    ${chalk4.dim(`#${rank}`)}  ${scoreColor(match.score.toFixed(1))}  ${chalk4.bold(match.job_title)} @ ${match.company}`);
+  if (showDetails) {
+    if (match.strengths.length > 0) {
+      console.log(`          ${chalk4.green("+")} ${match.strengths.join(", ")}`);
+    }
+    if (match.gaps.length > 0) {
+      console.log(`          ${chalk4.red("-")} ${match.gaps.join(", ")}`);
+    }
+    console.log(`          ${chalk4.dim(match.url)}`);
+  }
+}
+
+// src/commands/apply.ts
+import chalk5 from "chalk";
+import inquirer2 from "inquirer";
+
+// src/history/tracker.ts
+var HISTORY_FILE = "history.json";
+async function loadHistory() {
+  const data = await loadJson(HISTORY_FILE);
+  return data || { applications: [], last_updated: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function saveHistory(history) {
+  history.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+  await saveJson(HISTORY_FILE, history);
+}
+async function addApplication(record) {
+  const history = await loadHistory();
+  history.applications.push(record);
+  await saveHistory(history);
+}
+async function updateApplicationStatus(appId, status, notes) {
+  const history = await loadHistory();
+  const app = history.applications.find(
+    (a) => a.id === appId || a.id.startsWith(appId)
+  );
+  if (!app) return null;
+  app.status = status;
+  app.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  if (notes) app.notes = notes;
+  await saveHistory(history);
+  return app;
+}
+function findByJobId(history, jobId) {
+  return history.applications.find((a) => a.job_id === jobId);
+}
+function generateAppId() {
+  const ts = Date.now().toString(36).slice(-4);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `app_${ts}${rand}`;
+}
+
+// src/resume/tailorer.ts
+var SYSTEM_PROMPT5 = `You tailor a resume for a specific job. Given the candidate's skill data and target job, produce a tailored resume configuration.
+
+Rules:
+- professional_summary: Write 3-4 sentences as if the candidate wrote them. No mention of scores, tools, analysis systems, or automation. Sound natural and specific to this role.
+- project_order: Rank the candidate's projects by relevance to this job. Most relevant first. Use exact project names.
+- bullet_emphasis: For each project, write 2-4 resume bullet points that best align with the job. Start with action verbs, include metrics where possible (commits, LOC, active days).
+- skills_order: List the candidate's tech skills reordered by relevance to this job. Most relevant first. Use exact skill names from the profile.
+
+Return JSON only, no markdown fences. Schema:
+{
+  "professional_summary": "string",
+  "project_order": ["project names"],
+  "bullet_emphasis": { "ProjectName": ["bullet1", "bullet2"] },
+  "skills_order": ["skill names"]
+}`;
+async function tailorResume(graph, job, requirements, match) {
+  const identity = graph.builder_identity;
+  const profileLines = [
+    `Name: ${identity.name}`,
+    `Role: ${identity.primary_role}`
+  ];
+  const skills = Object.entries(graph.tech_stack).sort((a, b) => b[1].proficiency - a[1].proficiency).slice(0, 15);
+  if (skills.length > 0) {
+    profileLines.push("Skills (code-verified):");
+    for (const [name, data] of skills) {
+      profileLines.push(`  ${name}: ${data.loc.toLocaleString()} LOC, ${data.projects} projects`);
+    }
+  }
+  if (graph.projects.length > 0) {
+    profileLines.push("Projects:");
+    for (const proj of graph.projects) {
+      profileLines.push(`  ${proj.name}: ${proj.domain} \u2014 ${proj.stack.slice(0, 5).join(", ")} \u2014 ${proj.commits} commits, ${proj.active_days} active days`);
+      if (proj.description) profileLines.push(`    ${proj.description}`);
+    }
+  }
+  if (identity.previous_companies.length > 0) {
+    profileLines.push("Work History:");
+    for (const w of identity.previous_companies) {
+      profileLines.push(`  ${w.role} @ ${w.company} (${w.start_year}-${w.end_year || "present"})`);
+    }
+  }
+  const jobLines = [
+    `Title: ${job.title}`,
+    `Company: ${job.company}`,
+    `Must have: ${requirements.must_have_skills.join(", ")}`,
+    `Nice to have: ${requirements.nice_to_have_skills.join(", ")}`,
+    `Tech stack: ${requirements.tech_stack.join(", ")}`,
+    `Domain: ${requirements.domain}`,
+    `Match strengths: ${match.strengths.join(", ")}`
+  ];
+  const prompt = `CANDIDATE PROFILE:
+${profileLines.join("\n")}
+
+TARGET JOB:
+${jobLines.join("\n")}`;
+  const result = await callHaikuJson(SYSTEM_PROMPT5, prompt, 2048);
+  return {
+    job_id: job.id,
+    professional_summary: result.professional_summary || "",
+    project_order: result.project_order || graph.projects.map((p) => p.name),
+    bullet_emphasis: result.bullet_emphasis || {},
+    skills_order: result.skills_order || Object.keys(graph.tech_stack),
+    generated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/resume/pdf-builder.ts
+import PDFDocument from "pdfkit";
+import { writeFile as writeFile2 } from "fs/promises";
+import { join as join10 } from "path";
+var MARGIN = 54;
+var PAGE_WIDTH = 612;
+var CONTENT_WIDTH = PAGE_WIDTH - MARGIN * 2;
+var FONT_BODY = "Helvetica";
+var FONT_BOLD = "Helvetica-Bold";
+var SIZE_NAME = 18;
+var SIZE_SECTION = 12;
+var SIZE_BODY = 10.5;
+var SIZE_SMALL = 9.5;
+var COLOR_BLACK = "#000000";
+var COLOR_GRAY = "#444444";
+var SKILL_CATEGORIES = {
+  Languages: ["TypeScript", "JavaScript", "Python", "Rust", "Go", "Java", "C", "C++", "C#", "Ruby", "PHP", "Swift", "Kotlin", "Dart", "Scala", "Elixir", "Haskell", "SQL", "Shell", "Lua", "R", "Zig"],
+  Frameworks: ["React", "React Native", "Next.js", "Vue", "Nuxt", "Svelte", "SvelteKit", "Angular", "Express", "Fastify", "NestJS", "Django", "Flask", "FastAPI", "Actix", "Axum", "Gin", "Fiber", "Expo", "Hono", "Remix", "Astro", "Gatsby", "Solid"],
+  "Data & AI": ["Prisma", "Drizzle", "TypeORM", "Sequelize", "Mongoose", "SQLAlchemy", "Pandas", "NumPy", "TensorFlow", "PyTorch", "LangChain", "Anthropic SDK", "OpenAI"],
+  Infrastructure: ["Supabase", "Firebase", "Docker", "Kubernetes", "AWS", "GCP", "Azure", "Vercel", "Tokio", "Serde"]
+};
+async function generateResumePdf(graph, tailoring) {
+  return new Promise((resolve3, reject) => {
+    const doc = new PDFDocument({
+      size: "LETTER",
+      margins: { top: MARGIN, bottom: MARGIN, left: MARGIN, right: MARGIN }
+    });
+    const chunks = [];
+    doc.on("data", (chunk) => chunks.push(chunk));
+    doc.on("end", () => resolve3(Buffer.concat(chunks)));
+    doc.on("error", reject);
+    const identity = graph.builder_identity;
+    doc.font(FONT_BOLD).fontSize(SIZE_NAME).fillColor(COLOR_BLACK);
+    doc.text(identity.name || "Builder", { align: "center" });
+    doc.moveDown(0.3);
+    const contactParts = [];
+    if (identity.email) contactParts.push(identity.email);
+    if (identity.phone) contactParts.push(identity.phone);
+    const linkParts = [];
+    for (const [, url] of Object.entries(identity.links || {})) {
+      if (url) linkParts.push(url);
+    }
+    doc.font(FONT_BODY).fontSize(SIZE_SMALL).fillColor(COLOR_GRAY);
+    if (contactParts.length > 0) {
+      doc.text(contactParts.join(" | "), { align: "center" });
+    }
+    if (linkParts.length > 0) {
+      doc.text(linkParts.join(" | "), { align: "center" });
+    }
+    doc.moveDown(0.8);
+    renderSectionHeader(doc, "PROFESSIONAL SUMMARY");
+    doc.font(FONT_BODY).fontSize(SIZE_BODY).fillColor(COLOR_BLACK);
+    doc.text(tailoring.professional_summary, { lineGap: 2 });
+    doc.moveDown(0.6);
+    renderSectionHeader(doc, "TECHNICAL SKILLS");
+    const categorized = categorizeSkills(tailoring.skills_order, graph);
+    doc.font(FONT_BODY).fontSize(SIZE_BODY).fillColor(COLOR_BLACK);
+    for (const [category, skills] of Object.entries(categorized)) {
+      if (skills.length > 0) {
+        doc.font(FONT_BOLD).text(`${category}: `, { continued: true });
+        doc.font(FONT_BODY).text(skills.join(", "));
+      }
+    }
+    doc.moveDown(0.6);
+    if (identity.previous_companies && identity.previous_companies.length > 0) {
+      renderSectionHeader(doc, "WORK EXPERIENCE");
+      for (const work of identity.previous_companies) {
+        renderWorkEntry(doc, work);
+      }
+      doc.moveDown(0.3);
+    }
+    if (graph.projects.length > 0) {
+      renderSectionHeader(doc, "PROJECTS");
+      const orderedProjects = orderProjects(graph.projects, tailoring.project_order);
+      for (const proj of orderedProjects.slice(0, 4)) {
+        renderProject(doc, proj, tailoring.bullet_emphasis[proj.name] || []);
+      }
+      doc.moveDown(0.3);
+    }
+    if (identity.education && identity.education.length > 0) {
+      renderSectionHeader(doc, "EDUCATION");
+      for (const edu of identity.education) {
+        renderEducation(doc, edu);
+      }
+    }
+    doc.end();
+  });
+}
+async function saveResumePdf(pdfBuffer, jobId) {
+  await ensureSubDir("resumes");
+  const filename = `${jobId.replace(/[^a-zA-Z0-9_-]/g, "_")}.pdf`;
+  const filepath = join10(getPath("resumes"), filename);
+  await writeFile2(filepath, pdfBuffer);
+  return filepath;
+}
+function renderSectionHeader(doc, title) {
+  doc.font(FONT_BOLD).fontSize(SIZE_SECTION).fillColor(COLOR_BLACK);
+  doc.text(title);
+  doc.moveTo(MARGIN, doc.y + 2).lineTo(PAGE_WIDTH - MARGIN, doc.y + 2).strokeColor(COLOR_GRAY).lineWidth(0.5).stroke();
+  doc.moveDown(0.4);
+}
+function renderWorkEntry(doc, work) {
+  const dateRange = `${work.start_year} - ${work.end_year || "Present"}`;
+  doc.font(FONT_BOLD).fontSize(SIZE_BODY).fillColor(COLOR_BLACK);
+  doc.text(`${work.role}`, { continued: true });
+  doc.font(FONT_BODY).text(` | ${work.company}`);
+  doc.font(FONT_BODY).fontSize(SIZE_SMALL).fillColor(COLOR_GRAY);
+  doc.text(dateRange);
+  doc.fillColor(COLOR_BLACK).fontSize(SIZE_BODY);
+  if (work.bullets && work.bullets.length > 0) {
+    for (const bullet of work.bullets) {
+      doc.text(`  \u2022  ${bullet}`, { indent: 10, lineGap: 1 });
+    }
+  }
+  doc.moveDown(0.4);
+}
+function renderProject(doc, proj, bullets) {
+  const stackStr = proj.stack.slice(0, 5).join(", ");
+  doc.font(FONT_BOLD).fontSize(SIZE_BODY).fillColor(COLOR_BLACK);
+  doc.text(proj.name, { continued: true });
+  doc.font(FONT_BODY).fillColor(COLOR_GRAY).text(` | ${proj.domain || "project"} | ${stackStr}`);
+  doc.fillColor(COLOR_BLACK);
+  if (proj.description) {
+    doc.font(FONT_BODY).fontSize(SIZE_BODY).text(proj.description, { lineGap: 1 });
+  }
+  const displayBullets = bullets.length > 0 ? bullets : generateDefaultBullets(proj);
+  for (const bullet of displayBullets.slice(0, 3)) {
+    doc.text(`  \u2022  ${bullet}`, { indent: 10, lineGap: 1 });
+  }
+  doc.moveDown(0.4);
+}
+function renderEducation(doc, edu) {
+  doc.font(FONT_BOLD).fontSize(SIZE_BODY).fillColor(COLOR_BLACK);
+  doc.text(`${edu.degree} in ${edu.field}`, { continued: true });
+  doc.font(FONT_BODY).text(` | ${edu.institution} | ${edu.year}`);
+}
+function orderProjects(projects, order) {
+  const byName = new Map(projects.map((p) => [p.name, p]));
+  const ordered = [];
+  for (const name of order) {
+    const proj = byName.get(name);
+    if (proj) {
+      ordered.push(proj);
+      byName.delete(name);
+    }
+  }
+  for (const proj of byName.values()) {
+    ordered.push(proj);
+  }
+  return ordered;
+}
+function categorizeSkills(skillsOrder, graph) {
+  const allSkills = skillsOrder.length > 0 ? skillsOrder : Object.keys(graph.tech_stack);
+  const result = {};
+  const used = /* @__PURE__ */ new Set();
+  for (const [category, known] of Object.entries(SKILL_CATEGORIES)) {
+    const knownLower = new Set(known.map((k) => k.toLowerCase()));
+    const matched = allSkills.filter((s) => knownLower.has(s.toLowerCase()) && !used.has(s.toLowerCase()));
+    if (matched.length > 0) {
+      result[category] = matched;
+      matched.forEach((s) => used.add(s.toLowerCase()));
+    }
+  }
+  const remaining = allSkills.filter((s) => !used.has(s.toLowerCase()));
+  if (remaining.length > 0) {
+    result["Other"] = remaining;
+  }
+  return result;
+}
+function generateDefaultBullets(proj) {
+  const bullets = [];
+  if (proj.commits > 0) {
+    bullets.push(`${proj.commits} commits over ${proj.active_days} active days${proj.contributors > 1 ? ` with ${proj.contributors} contributors` : ""}`);
+  }
+  const langStr = Object.entries(proj.languages).sort((a, b) => b[1].loc - a[1].loc).slice(0, 3).map(([lang, { loc }]) => `${lang} (${loc.toLocaleString()} LOC)`).join(", ");
+  if (langStr) bullets.push(`Built with ${langStr}`);
+  return bullets;
+}
+
+// src/ats/submitter.ts
+import FormData from "form-data";
+async function submitApplication(job, pdfBuffer, identity) {
+  const registry = await loadRegistry();
+  const company = registry.find((c) => c.slug === job.company_slug);
+  if (!company) {
+    return { success: false, message: `Company not found in registry: ${job.company_slug}` };
+  }
+  const { source, rawId } = extractRawJobId(job.id);
+  switch (source) {
+    case "greenhouse":
+      return submitToGreenhouse(company.board_token, rawId, pdfBuffer, identity);
+    case "lever":
+      return submitToLever(company.board_token, rawId, pdfBuffer, identity);
+    case "ashby":
+      return submitToAshby(rawId, pdfBuffer, identity);
+    default:
+      return { success: false, message: `Unknown ATS source: ${source}` };
+  }
+}
+function extractRawJobId(normalizedId) {
+  if (normalizedId.startsWith("gh_")) return { source: "greenhouse", rawId: normalizedId.slice(3) };
+  if (normalizedId.startsWith("lv_")) return { source: "lever", rawId: normalizedId.slice(3) };
+  if (normalizedId.startsWith("ab_")) return { source: "ashby", rawId: normalizedId.slice(3) };
+  return { source: "unknown", rawId: normalizedId };
+}
+async function submitToGreenhouse(boardToken, rawJobId, pdfBuffer, identity) {
+  const url = `https://boards-api.greenhouse.io/v1/boards/${boardToken}/jobs/${rawJobId}`;
+  const nameParts = (identity.name || "").split(" ");
+  const firstName = nameParts[0] || "";
+  const lastName = nameParts.slice(1).join(" ") || "";
+  const form = new FormData();
+  form.append("first_name", firstName);
+  form.append("last_name", lastName);
+  form.append("email", identity.email);
+  if (identity.phone) form.append("phone", identity.phone);
+  form.append("resume", pdfBuffer, { filename: "resume.pdf", contentType: "application/pdf" });
+  if (identity.links?.github) form.append("urls[GitHub]", identity.links.github);
+  if (identity.links?.linkedin) form.append("urls[LinkedIn]", identity.links.linkedin);
+  if (identity.links?.portfolio) form.append("urls[Portfolio]", identity.links.portfolio);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: form.getHeaders(),
+      body: form.getBuffer(),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (response.ok) {
+      return { success: true, message: "Application submitted via Greenhouse", status: response.status };
+    }
+    const body = await response.text().catch(() => "");
+    return { success: false, message: `Greenhouse HTTP ${response.status}: ${body.slice(0, 200)}`, status: response.status };
+  } catch (err) {
+    return { success: false, message: `Greenhouse error: ${err.message}` };
+  }
+}
+async function submitToLever(boardToken, rawPostingId, pdfBuffer, identity) {
+  const url = `https://api.lever.co/v0/postings/${boardToken}/${rawPostingId}`;
+  const form = new FormData();
+  form.append("name", identity.name || "");
+  form.append("email", identity.email);
+  if (identity.phone) form.append("phone", identity.phone);
+  form.append("resume", pdfBuffer, { filename: "resume.pdf", contentType: "application/pdf" });
+  if (identity.links?.github) form.append("urls[GitHub]", identity.links.github);
+  if (identity.links?.linkedin) form.append("urls[LinkedIn]", identity.links.linkedin);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: form.getHeaders(),
+      body: form.getBuffer(),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (response.ok) {
+      return { success: true, message: "Application submitted via Lever", status: response.status };
+    }
+    const body = await response.text().catch(() => "");
+    return { success: false, message: `Lever HTTP ${response.status}: ${body.slice(0, 200)}`, status: response.status };
+  } catch (err) {
+    return { success: false, message: `Lever error: ${err.message}` };
+  }
+}
+async function submitToAshby(rawJobId, pdfBuffer, identity) {
+  const url = "https://api.ashbyhq.com/posting-api/applicationForm.submit";
+  const nameParts = (identity.name || "").split(" ");
+  const body = {
+    jobPostingId: rawJobId,
+    applicationForm: {
+      firstName: nameParts[0] || "",
+      lastName: nameParts.slice(1).join(" ") || "",
+      email: identity.email,
+      phone: identity.phone || "",
+      resume: {
+        filename: "resume.pdf",
+        mimeType: "application/pdf",
+        data: pdfBuffer.toString("base64")
+      }
+    }
+  };
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (response.ok) {
+      return { success: true, message: "Application submitted via Ashby", status: response.status };
+    }
+    const respBody = await response.text().catch(() => "");
+    return { success: false, message: `Ashby HTTP ${response.status}: ${respBody.slice(0, 200)}`, status: response.status };
+  } catch (err) {
+    return { success: false, message: `Ashby error: ${err.message}` };
+  }
+}
+
+// src/commands/apply.ts
+async function applyCommand(jobId, options) {
+  header("\n  HireGraph Apply\n");
+  if (!isApiKeyConfigured()) {
+    warn("No API key detected. Run hiregraph inside Claude Code or Cursor.");
+    return;
+  }
+  const graph = await loadGraph();
+  if (!graph || graph.projects.length === 0) {
+    error("No skill graph found. Run `hiregraph scan <path>` first.");
+    return;
+  }
+  if (!graph.builder_identity.name || !graph.builder_identity.email) {
+    error("Name and email required. Run `hiregraph init` first.");
+    return;
+  }
+  const matchRun = await loadLatestMatches();
+  if (!matchRun) {
+    error("No match results found. Run `hiregraph matches` first.");
+    return;
+  }
+  const jobsMap = await loadJobsMap();
+  const requirementsMap = await loadRequirementsMap();
+  const history = await loadHistory();
+  let targets;
+  if (options?.allAbove !== void 0) {
+    const threshold = options.allAbove;
+    const allMatches = [...matchRun.strong_matches, ...matchRun.suggested_matches];
+    targets = allMatches.filter((m) => m.score >= threshold);
+    info(`  Found ${targets.length} matches with score >= ${threshold}
+`);
+  } else if (jobId) {
+    const allMatches = [...matchRun.strong_matches, ...matchRun.suggested_matches];
+    const match = allMatches.find((m) => m.job_id === jobId);
+    if (!match) {
+      error(`Match not found for job ID: ${jobId}`);
+      info("Available matches:");
+      for (const m of allMatches.slice(0, 10)) {
+        console.log(`  ${chalk5.dim(m.job_id)} ${m.job_title} @ ${m.company} (${m.score})`);
+      }
+      return;
+    }
+    targets = [match];
+  } else {
+    error("Provide a job-id or use --all-above <score>");
+    info("Usage: hiregraph apply <job-id> [--review] [--dry-run]");
+    info("       hiregraph apply --all-above 8");
+    return;
+  }
+  let applied = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const match of targets) {
+    if (findByJobId(history, match.job_id)) {
+      dim(`  Skipped (already applied): ${match.job_title} @ ${match.company}`);
+      skipped++;
+      continue;
+    }
+    const job = jobsMap.get(match.job_id);
+    const requirements = requirementsMap[match.job_id];
+    if (!job || !requirements) {
+      warn(`  Skipped (missing data): ${match.job_title} @ ${match.company}`);
+      failed++;
+      continue;
+    }
+    console.log(`
+  ${chalk5.bold(match.job_title)} @ ${match.company} (score: ${chalk5.green(String(match.score))})`);
+    start("Tailoring resume...");
+    let tailoring;
+    try {
+      tailoring = await tailorResume(graph, job, requirements, match);
+      succeed("Resume tailored");
+    } catch (err) {
+      fail(`Tailoring failed: ${err.message}`);
+      failed++;
+      continue;
+    }
+    if (options?.review) {
+      console.log();
+      console.log(`  ${chalk5.bold("Summary:")} ${tailoring.professional_summary}`);
+      console.log(`  ${chalk5.bold("Projects:")} ${tailoring.project_order.join(" > ")}`);
+      console.log(`  ${chalk5.bold("Skills:")} ${tailoring.skills_order.slice(0, 8).join(", ")}`);
+      console.log(`  ${chalk5.bold("Strengths:")} ${match.strengths.join(", ")}`);
+      console.log(`  ${chalk5.bold("Gaps:")} ${match.gaps.join(", ")}`);
+      console.log();
+      const { proceed } = await inquirer2.prompt([{
+        type: "confirm",
+        name: "proceed",
+        message: "Apply to this job?",
+        default: true
+      }]);
+      if (!proceed) {
+        dim("  Skipped by user");
+        skipped++;
+        continue;
+      }
+    }
+    start("Generating resume PDF...");
+    let pdfBuffer;
+    let resumePath;
+    try {
+      pdfBuffer = await generateResumePdf(graph, tailoring);
+      resumePath = await saveResumePdf(pdfBuffer, match.job_id);
+      succeed(`Resume saved: ${resumePath}`);
+    } catch (err) {
+      fail(`PDF generation failed: ${err.message}`);
+      failed++;
+      continue;
+    }
+    if (options?.dryRun) {
+      success(`  [dry-run] Resume generated but not submitted`);
+      applied++;
+      continue;
+    }
+    start("Submitting application...");
+    const result = await submitApplication(job, pdfBuffer, graph.builder_identity);
+    if (result.success) {
+      succeed(result.message);
+      const appId = generateAppId();
+      await addApplication({
+        id: appId,
+        job_id: match.job_id,
+        job_title: match.job_title,
+        company: match.company,
+        company_slug: match.company_slug,
+        url: match.url,
+        ats_source: job.source,
+        match_score: match.score,
+        resume_path: resumePath,
+        status: "applied",
+        applied_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      success(`  Applied! (${appId})`);
+      applied++;
+    } else {
+      fail(result.message);
+      failed++;
+    }
+    if (targets.length > 1) {
+      await new Promise((r) => setTimeout(r, 2e3));
+    }
+  }
+  console.log();
+  console.log(`  ${chalk5.bold("Summary:")}`);
+  console.log(`    Applied:  ${chalk5.green(String(applied))}`);
+  if (skipped > 0) console.log(`    Skipped:  ${chalk5.yellow(String(skipped))}`);
+  if (failed > 0) console.log(`    Failed:   ${chalk5.red(String(failed))}`);
+  console.log();
+}
+async function loadLatestMatches() {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  let run = await loadSubJson("matches", `${today}.json`);
+  if (run) return run;
+  const yesterday = new Date(Date.now() - 864e5).toISOString().slice(0, 10);
+  run = await loadSubJson("matches", `${yesterday}.json`);
+  return run;
+}
+async function loadJobsMap() {
+  const map = /* @__PURE__ */ new Map();
+  for (const source of ["greenhouse", "lever", "ashby"]) {
+    const cache = await loadSubJson("jobs", `${source}.json`);
+    if (cache) {
+      for (const job of cache.jobs) {
+        map.set(job.id, job);
+      }
+    }
+  }
+  return map;
+}
+async function loadRequirementsMap() {
+  const cache = await loadSubJson("jobs", "parsed.json");
+  return cache?.requirements || {};
+}
+
+// src/commands/history.ts
+import chalk6 from "chalk";
+var VALID_STATUSES = [
+  "applied",
+  "screening",
+  "interview",
+  "offer",
+  "rejected",
+  "withdrawn",
+  "no-response"
+];
+var STATUS_COLORS = {
+  applied: chalk6.cyan,
+  screening: chalk6.blue,
+  interview: chalk6.green,
+  offer: chalk6.bold.green,
+  rejected: chalk6.red,
+  withdrawn: chalk6.dim,
+  "no-response": chalk6.yellow
+};
+async function historyCommand(action, id, options) {
+  if (action === "update" && id) {
+    await handleUpdate(id, options?.status, options?.notes);
+    return;
+  }
+  await handleList();
+}
+async function handleList() {
+  const history = await loadHistory();
+  if (history.applications.length === 0) {
+    info("\n  No applications yet. Run `hiregraph apply <job-id>` to apply.\n");
+    return;
+  }
+  header(`
+  HireGraph Application History (${history.applications.length})
+`);
+  const sorted = [...history.applications].sort(
+    (a, b) => new Date(b.applied_at).getTime() - new Date(a.applied_at).getTime()
+  );
+  for (const app of sorted) {
+    const colorFn = STATUS_COLORS[app.status] || chalk6.white;
+    const age = getTimeAgo2(app.applied_at);
+    console.log(
+      `  ${chalk6.dim(app.id.padEnd(14))} ${app.job_title.padEnd(35)} @ ${app.company.padEnd(18)} ${colorFn(app.status.padEnd(12))} ${chalk6.dim(age)}`
+    );
+    if (app.notes) {
+      console.log(`  ${" ".repeat(14)} ${chalk6.dim(`Notes: ${app.notes}`)}`);
+    }
+  }
+  console.log();
+}
+async function handleUpdate(id, status, notes) {
+  if (!status) {
+    error(`Status required. Valid: ${VALID_STATUSES.join(", ")}`);
+    return;
+  }
+  if (!VALID_STATUSES.includes(status)) {
+    error(`Invalid status "${status}". Valid: ${VALID_STATUSES.join(", ")}`);
+    return;
+  }
+  const updated = await updateApplicationStatus(id, status, notes);
+  if (!updated) {
+    error(`Application not found: ${id}`);
+    return;
+  }
+  const colorFn = STATUS_COLORS[updated.status] || chalk6.white;
+  success(`Updated ${updated.id}: ${updated.job_title} @ ${updated.company} -> ${colorFn(updated.status)}`);
+}
+function getTimeAgo2(isoDate) {
+  const diff = Date.now() - new Date(isoDate).getTime();
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("hiregraph").description("Turn your code into job applications. Local-first CLI that scans codebases and builds skill graphs.").version("0.1.0");
+program.command("init").description("Set up your builder profile (resume upload + preferences)").action(initCommand);
+program.command("scan").description("Scan a project and update your skill graph").argument("[path]", "Path to the project directory", ".").action(scanCommand);
+program.command("status").description("Show your current skill graph summary").action(statusCommand);
+program.command("jobs").description("Fetch job listings from Greenhouse, Lever, and Ashby boards").option("--refresh", "Force refresh cached jobs").option("--ats <type>", "Filter by ATS type (greenhouse, lever, ashby)").option("--limit <n>", "Show sample of N job titles", parseInt).action(jobsCommand);
+program.command("matches").description("Match your skill graph against fetched jobs").option("--refresh", "Re-fetch jobs before matching").option("--top <n>", "Number of candidates for LLM evaluation (default 50)", parseInt).option("--verbose", "Show detailed reasoning for all matches").action(matchesCommand);
+program.command("apply").description("Generate a tailored resume and submit to ATS").argument("[job-id]", "Job ID to apply to").option("--all-above <score>", "Apply to all matches above this score", parseFloat).option("--review", "Review each resume before submitting").option("--dry-run", "Generate resume PDF without submitting").action(applyCommand);
+program.command("history").description("View and manage your application history").argument("[action]", 'Action: "update"').argument("[id]", "Application ID").option("--status <status>", "New status (applied, screening, interview, offer, rejected, withdrawn, no-response)").option("--notes <notes>", "Optional notes").action(historyCommand);
+program.parse();
+//# sourceMappingURL=index.js.map