codeimpact 0.3.2 → 0.4.0

package/dist/index.js

@@ -8663,22 +8663,1290 @@ var init_research_trust = __esm({
   }
 });
 
-// src/core/agents/research-engine.ts
-import { existsSync as existsSync25, readFileSync as readFileSync20, writeFileSync as writeFileSync15, mkdirSync as mkdirSync15, readdirSync as readdirSync7 } from "fs";
+// src/core/agents/hardcoded-knowledge.ts
+var TECH_KNOWLEDGE, FEATURE_NAME_RULES, FEATURE_NAME_PITFALLS, WELL_KNOWN_FEATURES, DIR_PURPOSE_MAP, SCOPE_LABELS, DOC_SOURCE_REGISTRY;
+var init_hardcoded_knowledge = __esm({
+  "src/core/agents/hardcoded-knowledge.ts"() {
+    "use strict";
+    TECH_KNOWLEDGE = {
+      "express": {
+        rules: [
+          "Use Router() for modular route definitions",
+          "Always register error handler middleware last (4 args: err, req, res, next)"
+        ],
+        pitfalls: [
+          "Forgetting to call next() in middleware causes request to hang",
+          "Async errors in handlers need explicit try/catch or express-async-errors"
+        ]
+      },
+      "hono": {
+        rules: [
+          "Use app.route() for modular route grouping",
+          "Return c.json() or c.text() \u2014 do not use res.send()"
+        ],
+        pitfalls: [
+          "Hono middleware must call next() or return a Response \u2014 skipping both hangs the request"
+        ]
+      },
+      "better-sqlite3": {
+        rules: [
+          "Use db.prepare().all() for SELECT, db.prepare().run() for INSERT/UPDATE/DELETE",
+          "better-sqlite3 is synchronous \u2014 do NOT use async/await with db calls",
+          "All database access should go through a single module"
+        ],
+        pitfalls: [
+          "db.exec() returns nothing \u2014 using it for SELECT gives undefined",
+          'WAL mode must be set once after opening: db.pragma("journal_mode = WAL")'
+        ]
+      },
+      "stripe": {
+        rules: [
+          "Always verify webhook signatures before processing events",
+          "Use idempotency keys for payment creation to prevent double-charges"
+        ],
+        pitfalls: [
+          "Stripe webhook events may arrive out of order \u2014 handle idempotently",
+          "stripe.webhooks.constructEvent() throws on invalid signature \u2014 wrap in try/catch"
+        ]
+      },
+      "jsonwebtoken": {
+        rules: [
+          "Always use jwt.verify() \u2014 never trust jwt.decode() alone",
+          "Set explicit expiration (expiresIn) on all tokens"
+        ],
+        pitfalls: [
+          "Using jwt.decode() without verify() is a security vulnerability",
+          'The "none" algorithm attack \u2014 always specify algorithms: ["HS256"]'
+        ]
+      },
+      "@modelcontextprotocol/sdk": {
+        rules: [
+          "Use server.tool() to register MCP tools with zod schema validation",
+          "All tool handlers must return { content: [...] } response objects"
+        ],
+        pitfalls: [
+          "Tool names must be unique across the server \u2014 duplicates silently overwrite",
+          "Forgetting to call server.connect(transport) means no requests are handled"
+        ]
+      },
+      "prisma": {
+        rules: [
+          "Run npx prisma generate after schema changes",
+          "Use transactions for multi-table operations: prisma.$transaction()"
+        ],
+        pitfalls: [
+          "Forgetting prisma generate after schema change causes type mismatches at runtime",
+          "N+1 queries \u2014 use include/select to eagerly load relations"
+        ]
+      },
+      "zod": {
+        rules: [
+          "Define schemas once, derive TypeScript types with z.infer<typeof schema>",
+          "Use .safeParse() in handlers for graceful error handling"
+        ],
+        pitfalls: [
+          ".parse() throws on invalid data \u2014 use .safeParse() in request handlers"
+        ]
+      },
+      "vitest": {
+        rules: [
+          "Use describe/it/expect patterns for test organization",
+          "Use vi.mock() for module mocking, vi.fn() for function stubs"
+        ],
+        pitfalls: [
+          "vi.mock() is hoisted to top of file \u2014 cannot access variables from outer scope"
+        ]
+      },
+      "web-tree-sitter": {
+        rules: [
+          "Initialize Parser with await Parser.init() before use",
+          "Load language WASM files with Parser.Language.load()"
+        ],
+        pitfalls: [
+          "Parser.init() must complete before any parsing \u2014 race condition if not awaited",
+          "WASM files must be bundled/copied to dist \u2014 not resolved from node_modules at runtime"
+        ]
+      },
+      "@xenova/transformers": {
+        rules: [
+          "Use pipeline() for high-level tasks, AutoModel for custom inference",
+          "Cache downloaded models by setting env.cacheDir"
+        ],
+        pitfalls: [
+          "First model load downloads weights (~100MB+) \u2014 cache for subsequent runs",
+          "ONNX runtime may fail on some architectures \u2014 test on target platform"
+        ]
+      },
+      "chokidar": {
+        rules: [
+          "Use chokidar.watch() with ignored patterns to skip node_modules",
+          'Handle both "add" and "change" events for file watching'
+        ],
+        pitfalls: [
+          "Not closing watcher on process exit leaks file handles",
+          "Rapid file changes may fire multiple events \u2014 debounce handlers"
+        ]
+      },
+      "react": {
+        rules: [
+          "Components must be pure \u2014 same props must produce same output",
+          "Use useState for local UI state, useReducer for complex state logic",
+          "Memoize expensive computations with useMemo, callbacks with useCallback"
+        ],
+        pitfalls: [
+          "Missing key prop in lists causes React reconciliation bugs \u2014 always use stable keys",
+          "useEffect with missing deps causes stale closures \u2014 lint rules catch most cases",
+          "Setting state during render causes infinite re-render loop"
+        ]
+      },
+      "react-router-dom": {
+        rules: [
+          "Use <Link> for navigation \u2014 never use <a href> for internal routes",
+          "Use useNavigate() for programmatic navigation in event handlers"
+        ],
+        pitfalls: [
+          "Routes must be nested under a <Router> provider \u2014 missing it causes runtime crash",
+          "useSearchParams() returns URLSearchParams \u2014 .get() returns null not undefined"
+        ]
+      },
+      "react-hook-form": {
+        rules: [
+          "Use register() for uncontrolled inputs, Controller for controlled (MUI, Radix)",
+          "Define validation with zod resolver \u2014 avoid inline validate functions"
+        ],
+        pitfalls: [
+          "Forgetting to call handleSubmit() wrapper \u2014 form submits without validation",
+          "watch() causes re-render on every change \u2014 use getValues() for one-time reads"
+        ]
+      },
+      "tailwindcss": {
+        rules: [
+          "Use Tailwind utility classes \u2014 avoid custom CSS unless absolutely necessary",
+          "Use cn() or clsx() for conditional class merging"
+        ],
+        pitfalls: [
+          "Dynamic class names like `bg-${color}-500` are purged \u2014 use full class names",
+          "Order matters for conflicting utilities \u2014 last class wins"
+        ]
+      },
+      "vite": {
+        rules: [
+          "Use import.meta.env for env variables \u2014 must be prefixed with VITE_",
+          "Configure aliases in vite.config.ts resolve.alias"
+        ],
+        pitfalls: [
+          "process.env is not available in Vite \u2014 use import.meta.env instead",
+          "Environment variables without VITE_ prefix are not exposed to client code"
+        ]
+      },
+      "next": {
+        rules: [
+          'Use server components by default \u2014 add "use client" only when needed',
+          "Data fetching in server components \u2014 no useEffect for initial data"
+        ],
+        pitfalls: [
+          "Importing client-only code (useState, useEffect) in server components crashes build",
+          "next/image requires explicit width/height or fill prop \u2014 missing causes error"
+        ]
+      },
+      "framer-motion": {
+        rules: [
+          "Use motion.div (not regular div) for animated elements",
+          "Define variants objects for reusable animation states"
+        ],
+        pitfalls: [
+          "AnimatePresence requires direct children to have unique key props",
+          "Exit animations only work when component is direct child of AnimatePresence"
+        ]
+      },
+      "d3": {
+        rules: [
+          "Use D3 for data transforms/scales, React for DOM rendering \u2014 avoid d3.select in React",
+          "Use useRef to get DOM reference for D3 direct DOM manipulation when needed"
+        ],
+        pitfalls: [
+          "Mixing D3 DOM manipulation with React causes conflicts \u2014 pick one rendering strategy",
+          "D3 scales are mutable \u2014 creating them in render without useMemo causes bugs"
+        ]
+      },
+      "zustand": {
+        rules: [
+          "Create stores with create() \u2014 use selectors to prevent unnecessary re-renders",
+          "Keep store state serializable \u2014 no functions or class instances in state"
+        ],
+        pitfalls: [
+          "Not using selectors subscribes to entire store \u2014 causes excess re-renders",
+          "Mutating state directly (state.x = y) does not trigger re-render \u2014 use set()"
+        ]
+      },
+      "@tanstack/react-query": {
+        rules: [
+          "Use useQuery for GET, useMutation for POST/PUT/DELETE",
+          "Set staleTime to avoid unnecessary refetches \u2014 default 0 refetches every mount"
+        ],
+        pitfalls: [
+          "Forgetting queryClient.invalidateQueries after mutation shows stale data",
+          "Query keys must be serializable arrays \u2014 objects in keys cause cache misses"
+        ]
+      }
+    };
+    FEATURE_NAME_RULES = {
+      server: [
+        "All tool/resource handlers must validate inputs before processing",
+        "Return structured error responses \u2014 never throw raw errors to clients"
+      ],
+      storage: [
+        "All database access should go through this module \u2014 no direct imports elsewhere",
+        "Use transactions for multi-step operations to ensure consistency"
+      ],
+      indexing: [
+        "Index operations should be idempotent \u2014 reindexing same file produces same result",
+        "Handle parse errors gracefully \u2014 a broken file should not crash the indexer"
+      ],
+      core: [
+        "Core modules should have no side effects on import",
+        "Export types alongside functions for downstream consumers"
+      ],
+      test: [
+        "Tests should be deterministic \u2014 no reliance on external services or timing",
+        "Clean up temporary files and directories in afterEach/afterAll hooks"
+      ],
+      knowledge: [
+        "Skill files must follow the agentskills.io SKILL.md format",
+        "Generated content must use marker comments to preserve manual edits"
+      ],
+      doc: [
+        "Generated docs must be kept in sync with source code changes",
+        "Use relative paths for internal links"
+      ],
+      auth: [
+        "Never store plain-text passwords \u2014 use bcrypt or argon2",
+        "Validate and sanitize all user inputs before processing"
+      ],
+      api: [
+        "All endpoints must validate request bodies/params before processing",
+        "Return consistent error response shapes across all endpoints"
+      ],
+      components: [
+        "Components should be pure \u2014 derive UI from props, avoid internal side effects",
+        "Use composition over inheritance \u2014 prefer small, focused components",
+        "Co-locate styles, types, and tests with the component file"
+      ],
+      pages: [
+        "Pages handle routing and data fetching \u2014 delegate UI to components",
+        "Keep page components thin \u2014 extract business logic to hooks or services"
+      ],
+      hooks: [
+        'Custom hooks must start with "use" prefix',
+        "Keep hooks focused on one concern \u2014 avoid monolithic hooks",
+        "Hooks should be reusable \u2014 avoid coupling to specific component internals"
+      ],
+      layouts: [
+        "Layouts define page structure \u2014 children should not assume layout behavior",
+        "Keep layouts thin \u2014 avoid business logic in layout wrappers"
+      ],
+      views: [
+        "Views handle routing and data fetching \u2014 delegate UI to components",
+        "Keep view components thin \u2014 extract business logic to hooks or services"
+      ],
+      services: [
+        "Services handle API communication \u2014 keep HTTP details out of components",
+        "Return typed responses \u2014 avoid returning raw API responses"
+      ],
+      stores: [
+        "Keep store state minimal \u2014 derive computed values instead of storing them",
+        "Actions should be thin \u2014 delegate complex logic to services"
+      ],
+      store: [
+        "Keep store state minimal \u2014 derive computed values instead of storing them",
+        "Actions should be thin \u2014 delegate complex logic to services"
+      ],
+      contexts: [
+        "Context should hold only values that many components need \u2014 avoid overuse",
+        "Split large contexts into focused providers to prevent unnecessary re-renders"
+      ],
+      providers: [
+        "Provider order matters \u2014 auth before data fetching, theme before UI",
+        "Keep providers thin \u2014 initialize services, do not embed business logic"
+      ],
+      routes: [
+        "Route definitions should be declarative \u2014 avoid complex inline logic",
+        "Use lazy loading for route components to optimize bundle size"
+      ]
+    };
+    FEATURE_NAME_PITFALLS = {
+      server: [
+        "Unhandled promise rejections in handlers crash the process \u2014 always catch async errors",
+        "Adding middleware order matters \u2014 auth before route handlers"
+      ],
+      storage: [
+        "Forgetting to close database connections leaks file handles",
+        "Concurrent writes without transactions may cause data corruption"
+      ],
+      indexing: [
+        "Large files can cause out-of-memory \u2014 set size limits on parsed content",
+        "File paths must be normalized (forward slashes) for cross-platform compatibility"
+      ],
+      core: [
+        "Circular imports between core modules cause runtime errors \u2014 check dependency direction",
+        "Changing public API signatures breaks downstream consumers"
+      ],
+      test: [
+        "Tests sharing mutable state between runs cause flaky failures",
+        "Temp directories not cleaned up fill disk over repeated test runs"
+      ],
+      components: [
+        "Missing key prop in lists causes React reconciliation bugs \u2014 always use stable keys",
+        "Direct DOM manipulation bypasses React \u2014 use refs only when necessary",
+        "Prop drilling through 3+ levels signals need for context or composition"
+      ],
+      pages: [
+        "Data fetching in render causes waterfall requests \u2014 use loaders or top-level hooks",
+        "Missing error boundaries let one page crash the whole app"
+      ],
+      hooks: [
+        "Missing deps in useEffect cause stale closures \u2014 React will warn but won't auto-fix",
+        "Hooks called conditionally break React \u2014 hooks must be called in same order every render"
+      ],
+      services: [
+        "Not handling API errors shows raw errors to users \u2014 always catch and transform",
+        "Caching stale data causes UI inconsistency \u2014 invalidate cache on mutations"
+      ],
+      stores: [
+        "Mutating state directly causes silent bugs \u2014 always return new references",
+        "Large store updates trigger unnecessary re-renders \u2014 split into focused slices"
+      ],
+      store: [
+        "Mutating state directly causes silent bugs \u2014 always return new references",
+        "Large store updates trigger unnecessary re-renders \u2014 split into focused slices"
+      ]
+    };
+    WELL_KNOWN_FEATURES = /* @__PURE__ */ new Set([
+      "server",
+      "storage",
+      "indexing",
+      "core",
+      "test",
+      "knowledge",
+      "doc",
+      "auth",
+      "api",
+      "billing",
+      "cli",
+      "components",
+      "pages",
+      "hooks",
+      "layouts",
+      "views",
+      "services",
+      "stores",
+      "store",
+      "contexts",
+      "providers",
+      "routes"
+    ]);
+    DIR_PURPOSE_MAP = {
+      // Backend
+      core: "Core business logic and domain modules",
+      server: "Server, transports, and request handling",
+      storage: "Database access and persistence",
+      indexing: "Code indexing and symbol extraction",
+      api: "API routes and handlers",
+      auth: "Authentication and authorization",
+      billing: "Payment processing",
+      test: "Tests and evaluation harness",
+      tests: "Tests and evaluation harness",
+      doc: "Documentation",
+      knowledge: "AI knowledge system",
+      cli: "Command-line interface",
+      base: "Base configuration and fixtures",
+      src: "Application source code",
+      lib: "Shared utilities",
+      // Frontend / React
+      components: "Reusable UI components",
+      pages: "Page-level route components",
+      hooks: "Custom React hooks",
+      layouts: "Page layout wrappers",
+      views: "View components (page-level)",
+      features: "Feature modules (co-located logic + UI)",
+      services: "API client and service layer",
+      stores: "State management (stores/slices)",
+      store: "State management (stores/slices)",
+      utils: "Utility functions and helpers",
+      contexts: "React context providers",
+      providers: "App-level providers and wrappers",
+      routes: "Route definitions and navigation",
+      assets: "Static assets (images, fonts, icons)",
+      styles: "Global styles and theme configuration",
+      types: "TypeScript type definitions",
+      config: "App configuration",
+      middleware: "Request/response middleware",
+      models: "Data models and schemas",
+      controllers: "Request handlers (MVC)",
+      resolvers: "GraphQL resolvers",
+      schemas: "Data schemas and validation",
+      migrations: "Database migrations",
+      // Go
+      cmd: "CLI entry points and commands",
+      pkg: "Reusable library packages",
+      internal: "Private packages (unexported)",
+      // Rust
+      bin: "Binary entry points",
+      benches: "Benchmarks",
+      // Python
+      templates: "Template files (HTML, Jinja2)",
+      static: "Static files for web serving",
+      management: "Management commands (Django)",
+      // General
+      scripts: "Build/deploy/automation scripts",
+      tools: "Developer tools and utilities",
+      docs: "Documentation",
+      examples: "Example code and demos",
+      fixtures: "Test fixtures and sample data",
+      mocks: "Mock objects for testing",
+      helpers: "Helper functions and utilities",
+      adapters: "External service adapters",
+      ports: "Port interfaces (hexagonal architecture)",
+      domain: "Domain logic (DDD)",
+      entities: "Domain entities",
+      repositories: "Data access repositories",
+      handlers: "Request/event handlers",
+      events: "Event definitions and dispatchers",
+      jobs: "Background jobs and workers",
+      workers: "Background workers",
+      queues: "Job queue definitions",
+      cron: "Scheduled task definitions"
+    };
+    SCOPE_LABELS = {
+      "@radix-ui": "Radix UI (shadcn/ui primitives)",
+      "@tanstack": "TanStack (query/router/table)",
+      "@trpc": "tRPC",
+      "@nestjs": "NestJS",
+      "@prisma": "Prisma",
+      "@aws-sdk": "AWS SDK",
+      "@google-cloud": "Google Cloud SDK",
+      "@azure": "Azure SDK",
+      "@mui": "Material UI",
+      "@chakra-ui": "Chakra UI",
+      "@headlessui": "Headless UI",
+      "@mantine": "Mantine",
+      "@emotion": "Emotion CSS",
+      "@testing-library": "Testing Library",
+      "@storybook": "Storybook",
+      "@sentry": "Sentry",
+      "@opentelemetry": "OpenTelemetry",
+      "@supabase": "Supabase",
+      "@firebase": "Firebase",
+      "@stripe": "Stripe SDK"
+    };
+    DOC_SOURCE_REGISTRY = [
+      {
+        packageNames: ["express"],
+        docsUrl: "https://expressjs.com/en/api.html",
+        apiRefUrl: "https://expressjs.com/en/4x/api.html",
+        changelogUrl: "https://github.com/expressjs/express/blob/master/History.md"
+      },
+      {
+        packageNames: ["react", "react-dom"],
+        docsUrl: "https://react.dev/reference/react",
+        apiRefUrl: "https://react.dev/reference/react",
+        changelogUrl: "https://github.com/facebook/react/blob/main/CHANGELOG.md"
+      },
+      {
+        packageNames: ["next"],
+        docsUrl: "https://nextjs.org/docs",
+        apiRefUrl: "https://nextjs.org/docs/api-reference",
+        changelogUrl: "https://github.com/vercel/next.js/releases"
+      },
+      {
+        packageNames: ["typescript"],
+        docsUrl: "https://www.typescriptlang.org/docs/",
+        changelogUrl: "https://www.typescriptlang.org/docs/handbook/release-notes/overview.html"
+      },
+      {
+        packageNames: ["vitest"],
+        docsUrl: "https://vitest.dev/api/",
+        apiRefUrl: "https://vitest.dev/api/",
+        changelogUrl: "https://github.com/vitest-dev/vitest/releases"
+      },
+      {
+        packageNames: ["jest"],
+        docsUrl: "https://jestjs.io/docs/api",
+        apiRefUrl: "https://jestjs.io/docs/expect"
+      },
+      {
+        packageNames: ["prisma", "@prisma/client"],
+        docsUrl: "https://www.prisma.io/docs",
+        apiRefUrl: "https://www.prisma.io/docs/reference/api-reference",
+        changelogUrl: "https://github.com/prisma/prisma/releases"
+      },
+      {
+        packageNames: ["stripe"],
+        docsUrl: "https://docs.stripe.com/api",
+        changelogUrl: "https://docs.stripe.com/changelog"
+      },
+      {
+        packageNames: ["@modelcontextprotocol/sdk"],
+        docsUrl: "https://modelcontextprotocol.io/docs",
+        apiRefUrl: "https://github.com/modelcontextprotocol/typescript-sdk"
+      },
+      {
+        packageNames: ["better-sqlite3"],
+        docsUrl: "https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md",
+        apiRefUrl: "https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md"
+      },
+      {
+        packageNames: ["zod"],
+        docsUrl: "https://zod.dev/",
+        apiRefUrl: "https://zod.dev/"
+      },
+      {
+        packageNames: ["tailwindcss"],
+        docsUrl: "https://tailwindcss.com/docs"
+      },
+      {
+        packageNames: ["vite"],
+        docsUrl: "https://vitejs.dev/guide/",
+        apiRefUrl: "https://vitejs.dev/config/"
+      },
+      {
+        packageNames: ["passport"],
+        docsUrl: "https://www.passportjs.org/docs/"
+      },
+      {
+        packageNames: ["jsonwebtoken"],
+        docsUrl: "https://github.com/auth0/node-jsonwebtoken#readme"
+      },
+      {
+        packageNames: ["axios"],
+        docsUrl: "https://axios-http.com/docs/intro",
+        apiRefUrl: "https://axios-http.com/docs/api_intro"
+      },
+      {
+        packageNames: ["fastify"],
+        docsUrl: "https://fastify.dev/docs/latest/",
+        apiRefUrl: "https://fastify.dev/docs/latest/Reference/"
+      },
+      {
+        packageNames: ["drizzle-orm"],
+        docsUrl: "https://orm.drizzle.team/docs/overview"
+      },
+      {
+        packageNames: ["trpc", "@trpc/server", "@trpc/client"],
+        docsUrl: "https://trpc.io/docs"
+      },
+      {
+        packageNames: ["hono"],
+        docsUrl: "https://hono.dev/docs/",
+        apiRefUrl: "https://hono.dev/docs/api/hono"
+      }
+    ];
+  }
+});
+
+// src/core/agents/universal-inference.ts
+import { existsSync as existsSync25, readFileSync as readFileSync20, readdirSync as readdirSync7 } from "fs";
 import { join as join25 } from "path";
+function inferTechRulesAndPitfalls(tech, researchDir) {
+  const result = { rules: [], pitfalls: [] };
+  if (researchDir) {
+    const research = extractRulesFromResearch(tech, researchDir);
+    result.rules.push(...research.rules);
+    result.pitfalls.push(...research.pitfalls);
+  }
+  const hardcoded = TECH_KNOWLEDGE[tech.name];
+  if (hardcoded) {
+    for (const rule of hardcoded.rules) {
+      if (!result.rules.includes(rule)) result.rules.push(rule);
+    }
+    for (const pitfall of hardcoded.pitfalls) {
+      if (!result.pitfalls.includes(pitfall)) result.pitfalls.push(pitfall);
+    }
+  }
+  if (result.rules.length === 0 || result.pitfalls.length === 0) {
+    const category = classifyTechnology(tech);
+    const categoryKnowledge = CATEGORY_RULES[category];
+    if (categoryKnowledge) {
+      if (result.rules.length === 0) result.rules.push(...categoryKnowledge.rules);
+      if (result.pitfalls.length === 0) result.pitfalls.push(...categoryKnowledge.pitfalls);
+    }
+  }
+  if (result.rules.length === 0) {
+    result.rules.push(
+      `Follow ${tech.name} documentation for API usage patterns`,
+      "Pin dependency version to avoid unexpected breaking changes"
+    );
+  }
+  if (result.pitfalls.length === 0) {
+    result.pitfalls.push(
+      `Check ${tech.name} changelog when upgrading for breaking changes`,
+      "Ensure error handling covers all library-specific error types"
+    );
+  }
+  return result;
+}
+function classifyFeature(feature, importGraph) {
+  const name = feature.name.toLowerCase();
+  if (/^(server|api|routes?|controllers?|handlers?|endpoints?)$/.test(name)) return "api-layer";
+  if (/^(storage|db|database|models?|repositories|entities|migrations?)$/.test(name)) return "data-layer";
+  if (/^(core|domain|business|logic|engine|services?)$/.test(name)) return "business-logic";
+  if (/^(components?|ui|views?|pages?|layouts?|widgets?)$/.test(name)) return "ui-components";
+  if (/^(stores?|state|contexts?|providers?|hooks?)$/.test(name)) return "state-management";
+  if (/^(tests?|spec|__tests__|e2e|integration|fixtures?)$/.test(name)) return "testing";
+  if (/^(cli|cmd|commands?)$/.test(name)) return "cli";
+  if (/^(auth|authentication|authorization|security|identity)$/.test(name)) return "auth";
+  if (/^(docs?|documentation|knowledge)$/.test(name)) return "documentation";
+  if (/^(infra|infrastructure|deploy|ci|scripts?|tools?|config)$/.test(name)) return "infrastructure";
+  if (/^(utils?|helpers?|lib|shared|common|pkg|internal)$/.test(name)) return "utility";
+  if (feature.testFiles.length > 0 && feature.fileCount > 0) {
+    if (feature.testFiles.length / feature.fileCount > 0.5) return "testing";
+  }
+  if (importGraph) {
+    const featurePaths = new Set(feature.paths.map((p) => p.replace("/**", "")));
+    let importedByOthers = 0;
+    for (const [file2, imports] of importGraph) {
+      if (featurePaths.has(file2)) continue;
+      for (const imp of imports) {
+        for (const fp of featurePaths) {
+          if (imp.startsWith(fp)) importedByOthers++;
+        }
+      }
+    }
+    if (importedByOthers > 10) return "utility";
+  }
+  const techNames = feature.technologies.map((t) => t.toLowerCase());
+  if (techNames.some((t) => /prisma|typeorm|sqlalchemy|diesel|gorm|sequelize|drizzle/.test(t))) return "data-layer";
+  if (techNames.some((t) => /react|vue|svelte|angular|solid/.test(t))) return "ui-components";
+  if (techNames.some((t) => /express|fastify|hono|flask|gin|actix|django|rails/.test(t))) return "api-layer";
+  return "generic";
+}
+function inferDirectoryPurpose(dirName, context) {
+  const lower = dirName.toLowerCase();
+  const hardcoded = DIR_PURPOSE_MAP[lower];
+  if (hardcoded) return hardcoded;
+  if (/^(spec|__tests__|test_|_test)/.test(lower)) return "Tests and test helpers";
+  if (/^(build|dist|out|target|bin)$/.test(lower)) return "Build output";
+  if (/^(vendor|third[_-]?party|extern)/.test(lower)) return "Third-party vendored code";
+  if (/^(proto|protobuf|grpc)/.test(lower)) return "Protocol buffer definitions";
+  if (/^(gen|generated)/.test(lower)) return "Auto-generated code";
+  if (/^(i18n|l10n|locale|translations?)/.test(lower)) return "Internationalization and localization";
+  if (/^(plugin|extension|addon)s?$/.test(lower)) return "Plugin/extension modules";
+  if (/^(seed|seeds|fixtures|testdata)$/.test(lower)) return "Seed data and test fixtures";
+  if (/^(public|static|assets|resources|res)$/.test(lower)) return "Static assets and resources";
+  if (/^(cache|tmp|temp)$/.test(lower)) return "Temporary/cache files";
+  if (context) {
+    if (context.dominantExtensions) {
+      const exts = context.dominantExtensions;
+      if (exts.some((e) => /\.(test|spec)\.(ts|js|py|go|rs)$/.test(e))) return "Tests and test helpers";
+      if (exts.some((e) => /\.(css|scss|less|styl)$/.test(e))) return "Stylesheets";
+      if (exts.some((e) => /\.(html|hbs|ejs|pug|jinja2?)$/.test(e))) return "Template files";
+      if (exts.some((e) => /\.(proto)$/.test(e))) return "Protocol buffer definitions";
+    }
+    if (context.technologies) {
+      if (context.technologies.some((t) => /react|vue|svelte|angular/.test(t))) return "UI components";
+      if (context.technologies.some((t) => /express|fastify|flask|gin/.test(t))) return "Server handlers";
+    }
+  }
+  return `${capitalize(dirName)} module`;
+}
+function inferDataFlowFromGraph(features, importGraph) {
+  const names = features.map((f) => f.name);
+  if (importGraph && importGraph.size > 0) {
+    const flow = inferFlowFromTopology(features, importGraph);
+    if (flow.length >= 2) return flow;
+  }
+  return inferFlowFromNames(names);
+}
+function inferFlowFromTopology(features, importGraph) {
+  const featurePathMap = /* @__PURE__ */ new Map();
+  for (const f of features) {
+    for (const p of f.paths) {
+      const clean = p.replace("/**", "");
+      featurePathMap.set(clean, f.name);
+    }
+  }
+  const edges = /* @__PURE__ */ new Map();
+  for (const [file2, imports] of importGraph) {
+    const sourceFeature = findFeatureForFile(file2, featurePathMap);
+    if (!sourceFeature) continue;
+    for (const imp of imports) {
+      const targetFeature = findFeatureForFile(imp, featurePathMap);
+      if (!targetFeature || targetFeature === sourceFeature) continue;
+      if (!edges.has(sourceFeature)) edges.set(sourceFeature, /* @__PURE__ */ new Map());
+      const edgeMap = edges.get(sourceFeature);
+      edgeMap.set(targetFeature, (edgeMap.get(targetFeature) || 0) + 1);
+    }
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const outDegree = /* @__PURE__ */ new Map();
+  for (const f of features) {
+    inDegree.set(f.name, 0);
+    outDegree.set(f.name, 0);
+  }
+  for (const [source, targets] of edges) {
+    for (const [target, weight] of targets) {
+      inDegree.set(target, (inDegree.get(target) || 0) + weight);
+      outDegree.set(source, (outDegree.get(source) || 0) + weight);
+    }
+  }
+  const sorted = features.map((f) => ({
+    name: f.name,
+    score: (outDegree.get(f.name) || 0) - (inDegree.get(f.name) || 0)
+  })).sort((a, b) => b.score - a.score).map((f) => capitalize(f.name));
+  return sorted.slice(0, 6);
+}
+function findFeatureForFile(file2, featurePathMap) {
+  for (const [path, feature] of featurePathMap) {
+    if (file2.startsWith(path)) return feature;
+  }
+  return null;
+}
+function inferFlowFromNames(names) {
+  const flow = [];
+  const isFrontend = names.some((n) => /^(components?|pages?|views?|hooks?|widgets?)$/.test(n));
+  if (isFrontend) {
+    flow.push("User");
+    if (names.some((n) => /^(pages?|views?)$/.test(n))) flow.push("Pages");
+    if (names.some((n) => /^(components?|widgets?)$/.test(n))) flow.push("Components");
+    if (names.some((n) => /^hooks?$/.test(n))) flow.push("Hooks");
+    if (names.some((n) => /^services?$/.test(n))) flow.push("Services");
+    if (names.some((n) => /^(stores?|state)$/.test(n))) flow.push("Store");
+    return flow.length >= 2 ? flow : [];
+  }
+  if (names.some((n) => /^(server|api)$/.test(n))) flow.push("Request");
+  if (names.includes("server")) flow.push("Server");
+  if (names.includes("api")) flow.push("API");
+  if (names.some((n) => /^(controllers?|handlers?)$/.test(n))) flow.push("Controllers");
+  if (names.includes("core")) flow.push("Core");
+  if (names.some((n) => /^services?$/.test(n))) flow.push("Services");
+  if (names.some((n) => /^(storage|db|database)$/.test(n))) flow.push("Storage");
+  if (names.some((n) => /^(indexing|search)$/.test(n))) flow.push("Indexer");
+  if (names.some((n) => /^(cmd|cli)$/.test(n)) && flow.length === 0) {
+    flow.push("CLI");
+    if (names.includes("core")) flow.push("Core");
+    if (names.some((n) => /^(pkg|lib)$/.test(n))) flow.push("Lib");
+  }
+  return flow.length >= 2 ? flow : [];
+}
+function inferScopeLabel(scope, memberCount, researchDir) {
+  const hardcoded = SCOPE_LABELS[scope];
+  if (hardcoded) return hardcoded;
+  if (researchDir) {
+    try {
+      if (existsSync25(researchDir)) {
+        const files = readdirSync7(researchDir);
+        const scopeClean = scope.replace("@", "");
+        const match = files.find((f) => f.startsWith(scopeClean));
+        if (match) {
+          const content = readFileSync20(join25(researchDir, match), "utf-8");
+          const titleMatch = content.match(/^#\s+(.+?)(?:\s+—|\s+v)/m);
+          if (titleMatch?.[1]) return titleMatch[1];
+        }
+      }
+    } catch {
+    }
+  }
+  return `${scope} (${memberCount} packages)`;
+}
+function inferDocSource(packageName, source) {
+  for (const entry of DOC_SOURCE_REGISTRY) {
+    if (entry.packageNames.includes(packageName)) return entry;
+  }
+  const ecosystem = detectEcosystem(packageName, source);
+  switch (ecosystem) {
+    case "npm":
+      return {
+        packageNames: [packageName],
+        docsUrl: `https://www.npmjs.com/package/${packageName}`
+      };
+    case "go":
+      return {
+        packageNames: [packageName],
+        docsUrl: `https://pkg.go.dev/${packageName}`
+      };
+    case "rust":
+      return {
+        packageNames: [packageName],
+        docsUrl: `https://docs.rs/${packageName}`
+      };
+    case "python":
+      return {
+        packageNames: [packageName],
+        docsUrl: `https://pypi.org/project/${packageName}`
+      };
+    case "ruby":
+      return {
+        packageNames: [packageName],
+        docsUrl: `https://rubygems.org/gems/${packageName}`
+      };
+    case "java":
+      return {
+        packageNames: [packageName],
+        docsUrl: `https://mvnrepository.com/artifact/${packageName}`
+      };
+    case "dotnet":
+      return {
+        packageNames: [packageName],
+        docsUrl: `https://www.nuget.org/packages/${packageName}`
+      };
+    default:
+      return null;
+  }
+}
+function detectEcosystem(packageName, source) {
+  if (source) {
+    if (/package\.json|package-lock|yarn\.lock|pnpm-lock|bun\.lock/.test(source)) return "npm";
+    if (/go\.mod|go\.sum/.test(source)) return "go";
+    if (/Cargo\.toml|Cargo\.lock/.test(source)) return "rust";
+    if (/requirements\.txt|setup\.py|pyproject\.toml|Pipfile|poetry\.lock/.test(source)) return "python";
+    if (/Gemfile|\.gemspec/.test(source)) return "ruby";
+    if (/pom\.xml|build\.gradle/.test(source)) return "java";
+    if (/\.csproj|\.sln|nuget/.test(source)) return "dotnet";
+  }
+  if (packageName.startsWith("@") || /^[a-z][\w.-]*$/.test(packageName)) return "npm";
+  if (packageName.includes("/") && !packageName.startsWith("@")) return "go";
+  return "unknown";
+}
+function extractRulesFromResearch(tech, researchDir) {
+  const result = { rules: [], pitfalls: [] };
+  const safeName = tech.name.replace(/^@/, "").replace(/\//g, "__");
+  const candidates = [
+    join25(researchDir, `${safeName}@${tech.version}.md`),
+    join25(researchDir, `${tech.name}@${tech.version}.md`)
+  ];
+  let content = null;
+  for (const candidate of candidates) {
+    if (existsSync25(candidate)) {
+      try {
+        content = readFileSync20(candidate, "utf-8");
+        break;
+      } catch {
+      }
+    }
+  }
+  if (!content) {
+    try {
+      if (existsSync25(researchDir)) {
+        const files = readdirSync7(researchDir);
+        const match = files.find((f) => f.startsWith(`${safeName}@`));
+        if (match) {
+          content = readFileSync20(join25(researchDir, match), "utf-8");
+        }
+      }
+    } catch {
+    }
+  }
+  if (!content) return result;
+  const trustMatch = content.match(/trust_score:\s*([\d.]+)/);
+  if (trustMatch) {
+    const trustScore = parseFloat(trustMatch[1]);
+    if (trustScore < 0.5) return result;
+  }
+  const apiRules = extractBulletPoints(content, "Key API Patterns");
+  result.rules.push(...apiRules.slice(0, 5));
+  const pitfalls = extractBulletPoints(content, "Common Pitfalls");
+  result.pitfalls.push(...pitfalls.slice(0, 5));
+  const breakingChanges = extractBulletPoints(content, "Breaking Changes");
+  result.pitfalls.push(...breakingChanges.slice(0, 3));
+  return result;
+}
+function extractBulletPoints(content, sectionName) {
+  const lines = content.split("\n");
+  const points = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (line.match(new RegExp(`^##\\s+.*${escapeRegex2(sectionName)}`, "i"))) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && line.match(/^##\s/)) {
+      break;
+    }
+    if (inSection) {
+      const bulletMatch = line.match(/^[-*]\s+(.+)/);
+      if (bulletMatch?.[1]) {
+        const text = bulletMatch[1].trim();
+        if (text.length > 10 && text.length < 200) {
+          points.push(text);
+        }
+      }
+    }
+  }
+  return points;
+}
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function classifyTechnology(tech) {
+  const name = tech.name.toLowerCase();
+  if (/^(express|fastify|hono|koa|flask|gin|actix|django|rails|spring|laravel|fiber|echo|chi|rocket|axum|phoenix|sinatra|bottle)$/.test(name)) return "web-framework";
+  if (/^(react|vue|svelte|angular|solid|preact|lit|qwik|next|nuxt|gatsby|remix|astro|sveltekit)$/.test(name)) return "ui-framework";
+  if (/prisma|typeorm|sqlalchemy|diesel|gorm|sequelize|mongoose|drizzle|knex|bookshelf|objection|mikro-orm|ecto/.test(name)) return "orm";
+  if (/vitest|jest|pytest|mocha|jasmine|chai|supertest|testing-library|playwright|cypress|selenium/.test(name)) return "testing";
+  if (/passport|jsonwebtoken|jwt|oauth|bcrypt|argon2|lucia|next-auth|auth0|clerk|supertokens/.test(name)) return "auth";
+  if (/stripe|paypal|braintree|square|adyen|mollie/.test(name)) return "payment";
+  if (/vite|webpack|esbuild|rollup|parcel|turbopack|swc|babel|tsc/.test(name)) return "build-tool";
+  if (/zustand|redux|mobx|jotai|recoil|pinia|vuex|xstate|ngrx/.test(name)) return "state-management";
+  if (/tailwind|styled-components|emotion|css-modules|sass|less|postcss|bootstrap|bulma/.test(name)) return "css-framework";
+  if (/^(zod|yup|joi|ajv|superstruct|io-ts|valibot|typebox)$/.test(name)) return "validation";
+  if (/^(axios|got|ky|node-fetch|undici|superagent|request)$/.test(name)) return "api-client";
+  if (/better-sqlite3|pg|mysql2|redis|ioredis|mongodb|mariadb|sqlite3|tedious/.test(name)) return "database-driver";
+  if (/winston|pino|bunyan|log4js|morgan|loglevel|consola/.test(name)) return "logging";
+  return "general";
+}
+function deriveFeatureRules(feature, technologies, researchDir) {
+  const rules = [];
+  if (WELL_KNOWN_FEATURES.has(feature.name)) {
+    const nameRules = FEATURE_NAME_RULES[feature.name];
+    if (nameRules) rules.push(...nameRules);
+    const techRules = [];
+    for (const tech of technologies) {
+      const inferred = inferTechRulesAndPitfalls(tech, researchDir);
+      techRules.push(...inferred.rules);
+    }
+    for (const tr of techRules.slice(0, 2)) {
+      if (!rules.some((r) => r.includes(tr.split(" ")[0] || ""))) {
+        rules.push(tr);
+      }
+    }
+  } else {
+    for (const tech of technologies) {
+      const inferred = inferTechRulesAndPitfalls(tech, researchDir);
+      rules.push(...inferred.rules);
+    }
+    if (rules.length === 0) {
+      const category = classifyFeature(feature);
+      const categoryRules = FEATURE_CATEGORY_RULES[category];
+      if (categoryRules) {
+        rules.push(...categoryRules);
+      } else {
+        const nameRules = FEATURE_NAME_RULES[feature.name];
+        rules.push(...nameRules || [
+          "Follow existing patterns in this module for consistency",
+          "Export public API from index file \u2014 keep internal helpers unexported"
+        ]);
+      }
+    }
+  }
+  if (feature.paths.length > 0) {
+    const scope = feature.paths[0]?.replace("/**", "") || "";
+    rules.push(`Changes here should not import from other feature directories \u2014 keep ${scope} self-contained`);
+  }
+  return rules;
+}
+function deriveFeaturePitfalls(feature, technologies, researchDir) {
+  const pitfalls = [];
+  if (WELL_KNOWN_FEATURES.has(feature.name)) {
+    const namePitfalls = FEATURE_NAME_PITFALLS[feature.name];
+    if (namePitfalls) pitfalls.push(...namePitfalls);
+    for (const tech of technologies) {
+      const inferred = inferTechRulesAndPitfalls(tech, researchDir);
+      for (const p of inferred.pitfalls.slice(0, 1)) {
+        if (!pitfalls.includes(p)) pitfalls.push(p);
+      }
+    }
+  } else {
+    for (const tech of technologies) {
+      const inferred = inferTechRulesAndPitfalls(tech, researchDir);
+      pitfalls.push(...inferred.pitfalls);
+    }
+    if (pitfalls.length === 0) {
+      const namePitfalls = FEATURE_NAME_PITFALLS[feature.name];
+      if (namePitfalls) {
+        pitfalls.push(...namePitfalls);
+      } else {
+        const category = classifyFeature(feature);
+        const categoryPitfalls = FEATURE_CATEGORY_PITFALLS[category];
+        if (categoryPitfalls) {
+          pitfalls.push(...categoryPitfalls);
+        } else {
+          pitfalls.push(
+            "Check for null/undefined before property access on external data",
+            "Changing exports may break other modules that depend on this feature"
+          );
+        }
+      }
+    }
+  }
+  return pitfalls;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1).replace(/-/g, " ");
+}
+var CATEGORY_RULES, FEATURE_CATEGORY_RULES, FEATURE_CATEGORY_PITFALLS;
+var init_universal_inference = __esm({
+  "src/core/agents/universal-inference.ts"() {
+    "use strict";
+    init_hardcoded_knowledge();
+    CATEGORY_RULES = {
+      "web-framework": {
+        rules: [
+          "Validate all user inputs at the boundary \u2014 never trust request data",
+          "Use middleware for cross-cutting concerns (auth, logging, CORS)",
+          "Return consistent error response shapes across all endpoints"
+        ],
+        pitfalls: [
+          "Unhandled async errors crash the server \u2014 always use error middleware",
+          "Missing input validation leads to injection vulnerabilities"
+        ]
+      },
+      "ui-framework": {
+        rules: [
+          "Components should be pure \u2014 same props must produce same output",
+          "Use composition over inheritance \u2014 prefer small, focused components",
+          "Keep components focused on one responsibility"
+        ],
+        pitfalls: [
+          "Mutating state directly causes rendering bugs \u2014 always create new references",
+          "Missing key props in lists causes reconciliation bugs"
+        ]
+      },
+      "orm": {
+        rules: [
+          "Use migrations for all schema changes \u2014 never modify production DB directly",
+          "Use transactions for multi-table operations",
+          "Select only needed fields to avoid over-fetching"
+        ],
+        pitfalls: [
+          "N+1 query problem \u2014 use eager loading or batch queries for relations",
+          "Forgetting to run migrations after schema changes causes runtime errors"
+        ]
+      },
+      "testing": {
+        rules: [
+          "Tests should be deterministic \u2014 no reliance on external services or timing",
+          "Clean up test state between runs to prevent flaky failures",
+          "Use descriptive test names that explain the expected behavior"
+        ],
+        pitfalls: [
+          "Shared mutable state between tests causes flaky failures",
+          "Mocking too much makes tests pass but misses real integration bugs"
+        ]
+      },
+      "auth": {
+        rules: [
+          "Never store plain-text passwords \u2014 use bcrypt or argon2",
+          "Set explicit token expiration \u2014 never issue non-expiring tokens",
+          "Validate tokens on every request \u2014 never trust client-side auth state"
+        ],
+        pitfalls: [
+          "Using weak algorithms (MD5, SHA1) for password hashing is a security vulnerability",
+          "Not revoking tokens on logout allows session reuse"
+        ]
+      },
+      "payment": {
+        rules: [
+          "Always verify webhook signatures before processing payment events",
+          "Use idempotency keys for payment operations to prevent double-charges",
+          "Log all payment events for audit trails"
+        ],
+        pitfalls: [
+          "Webhook events may arrive out of order \u2014 handle idempotently",
+          "Not handling declined payments gracefully shows raw errors to users"
+        ]
+      },
+      "build-tool": {
+        rules: [
+          "Configure source maps for debugging in development",
+          "Set up separate dev/prod build configurations"
+        ],
+        pitfalls: [
+          "Large bundle sizes slow page load \u2014 use code splitting and tree shaking",
+          "Misconfigured output paths overwrite source files"
+        ]
+      },
+      "state-management": {
+        rules: [
+          "Keep store state minimal \u2014 derive computed values instead of storing them",
+          "Use selectors to prevent unnecessary re-renders",
+          "Keep store state serializable for debugging and persistence"
+        ],
+        pitfalls: [
+          "Mutating state directly causes silent bugs \u2014 always use the update API",
+          "Subscribing to entire store causes excessive re-renders"
+        ]
+      },
+      "css-framework": {
+        rules: [
+          "Follow the framework's utility-first or component-based approach consistently",
+          "Use conditional class merging utilities for dynamic styles"
+        ],
+        pitfalls: [
+          "Dynamic class names may be purged in production \u2014 use full static class names",
+          "Overriding framework styles with !important leads to unmaintainable CSS"
+        ]
+      },
+      "validation": {
+        rules: [
+          "Define schemas once \u2014 derive types from schemas to keep them in sync",
+          "Validate at system boundaries \u2014 user input, API responses, config files"
+        ],
+        pitfalls: [
+          "Throwing on validation failure crashes the app \u2014 use safe parse methods in handlers",
+          "Missing optional field validation causes runtime errors on undefined access"
+        ]
+      },
+      "api-client": {
+        rules: [
+          "Set request timeouts to prevent hanging on unresponsive servers",
+          "Handle network errors and HTTP errors separately"
+        ],
+        pitfalls: [
+          "Not handling network errors shows cryptic errors to users",
+          "Forgetting to set Content-Type header causes request parsing failures"
+        ]
+      },
+      "database-driver": {
+        rules: [
+          "Use parameterized queries \u2014 never concatenate user input into SQL",
+          "Use connection pooling for concurrent requests",
+          "Close connections properly to prevent resource leaks"
+        ],
+        pitfalls: [
+          "SQL injection from string concatenation \u2014 always use parameterized queries",
+          "Not closing connections leaks file handles or socket connections"
+        ]
+      },
+      "logging": {
+        rules: [
+          "Use structured logging (JSON) for machine-parseable log output",
+          "Set appropriate log levels \u2014 debug in dev, info/warn in production"
+        ],
+        pitfalls: [
+          "Logging sensitive data (passwords, tokens) is a security risk",
+          "Synchronous logging in hot paths impacts performance"
+        ]
+      },
+      "general": {
+        rules: [
+          "Follow existing patterns in this module for consistency",
+          "Pin dependency versions to avoid unexpected breaking changes"
+        ],
+        pitfalls: [
+          "Check changelog when upgrading for breaking changes",
+          "Ensure error handling covers library-specific error types"
+        ]
+      }
+    };
+    FEATURE_CATEGORY_RULES = {
+      "api-layer": [
+        "All endpoints must validate request bodies/params before processing",
+        "Return consistent error response shapes across all endpoints"
+      ],
+      "data-layer": [
+        "All database access should go through this module \u2014 no direct imports elsewhere",
+        "Use transactions for multi-step operations to ensure consistency"
+      ],
+      "business-logic": [
+        "Core modules should have no side effects on import",
+        "Export types alongside functions for downstream consumers"
+      ],
+      "ui-components": [
+        "Components should be pure \u2014 derive UI from props, avoid internal side effects",
+        "Use composition over inheritance \u2014 prefer small, focused components"
+      ],
+      "state-management": [
+        "Keep store state minimal \u2014 derive computed values instead of storing them",
+        "Actions should be thin \u2014 delegate complex logic to services"
+      ],
+      "testing": [
+        "Tests should be deterministic \u2014 no reliance on external services or timing",
+        "Clean up temporary files and directories in teardown hooks"
+      ],
+      "cli": [
+        "Validate all command-line arguments before processing",
+        "Provide helpful error messages with usage hints on invalid input"
+      ],
+      "auth": [
+        "Never store plain-text passwords \u2014 use bcrypt or argon2",
+        "Validate and sanitize all user inputs before processing"
+      ],
+      "documentation": [
+        "Generated docs must be kept in sync with source code changes",
+        "Use relative paths for internal links"
+      ],
+      "infrastructure": [
+        "Configuration should be environment-aware (dev/staging/prod)",
+        "Scripts should be idempotent \u2014 safe to run multiple times"
+      ],
+      "utility": [
+        "Utility functions should be pure \u2014 no side effects",
+        "Export public API from index file \u2014 keep internal helpers unexported"
+      ],
+      "generic": [
+        "Follow existing patterns in this module for consistency",
+        "Export public API from index file \u2014 keep internal helpers unexported"
+      ]
+    };
+    FEATURE_CATEGORY_PITFALLS = {
+      "api-layer": [
+        "Unhandled async errors crash the server \u2014 always catch errors in handlers",
+        "Missing input validation leads to injection vulnerabilities"
+      ],
+      "data-layer": [
+        "Forgetting to close connections leaks file handles",
+        "Concurrent writes without transactions may cause data corruption"
+      ],
+      "business-logic": [
+        "Circular imports between core modules cause runtime errors \u2014 check dependency direction",
+        "Changing public API signatures breaks downstream consumers"
+      ],
+      "ui-components": [
+        "Missing key prop in lists causes reconciliation bugs \u2014 always use stable keys",
+        "Direct DOM manipulation bypasses the framework \u2014 use refs only when necessary"
+      ],
+      "state-management": [
+        "Mutating state directly causes silent bugs \u2014 always return new references",
+        "Large store updates trigger unnecessary re-renders \u2014 split into focused slices"
+      ],
+      "testing": [
+        "Tests sharing mutable state between runs cause flaky failures",
+        "Temp directories not cleaned up fill disk over repeated test runs"
+      ],
+      "cli": [
+        "Missing error handling on subprocess execution causes silent failures",
+        "Not quoting file paths breaks on paths with spaces"
+      ],
+      "auth": [
+        "Using weak hashing algorithms is a security vulnerability",
+        "Not revoking tokens on logout allows session reuse"
+      ],
+      "documentation": [
+        "Stale documentation is worse than no documentation",
+        "Broken internal links confuse users \u2014 validate links on changes"
+      ],
+      "infrastructure": [
+        "Hardcoded secrets in config files are a security risk \u2014 use environment variables",
+        "Non-idempotent scripts cause issues on re-run"
+      ],
+      "utility": [
+        "Changing utility signatures breaks all callers \u2014 check usage before modifying",
+        "Missing error handling in utilities propagates errors to all consumers"
+      ],
+      "generic": [
+        "Check for null/undefined before property access on external data",
+        "Changing exports may break other modules that depend on this feature"
+      ]
+    };
+  }
+});
+
+// src/core/agents/research-engine.ts
+import { existsSync as existsSync26, readFileSync as readFileSync21, writeFileSync as writeFileSync15, mkdirSync as mkdirSync15, readdirSync as readdirSync8 } from "fs";
+import { join as join26 } from "path";
 async function researchTechnology(projectPath, tech, options) {
   const paths = getAgentWorkspacePaths(projectPath);
   const safeName = tech.name.replace(/^@/, "").replace(/\//g, "__");
   const fileName = `${safeName}@${tech.version}.md`;
-  const filePath = join25(paths.researchDir, fileName);
+  const filePath = join26(paths.researchDir, fileName);
   const relPath = `research/${fileName}`;
-  if (!options.force && existsSync25(filePath)) {
+  if (!options.force && existsSync26(filePath)) {
     const existing = readResearchFile(filePath);
     if (existing && !isStale(existing, options.cadenceHours)) {
       return { technology: tech.name, version: tech.version, file: relPath, status: "cached" };
     }
   }
-  const docSource = findDocSource(tech.name);
+  const docSource = inferDocSource(tech.name, tech.source);
   if (!docSource) {
     const stub = generateStubResearch(tech);
     mkdirSync15(paths.researchDir, { recursive: true });
@@ -8688,10 +9956,10 @@ async function researchTechnology(projectPath, tech, options) {
   try {
     const fetchFn = options.fetchFn || defaultFetch;
     const content = await fetchAndDistill(tech, docSource, fetchFn, options.maxTokensPerTech);
+    const isNew = !existsSync26(filePath);
     mkdirSync15(paths.researchDir, { recursive: true });
     writeFileSync15(filePath, content);
     const tokenCount = estimateTokens4(content);
-    const isNew = !existsSync25(filePath);
     return {
       technology: tech.name,
       version: tech.version,
@@ -8700,7 +9968,7 @@ async function researchTechnology(projectPath, tech, options) {
       tokenCount
     };
   } catch (err) {
-    if (!existsSync25(filePath)) {
+    if (!existsSync26(filePath)) {
       const stub = generateStubResearch(tech);
       mkdirSync15(paths.researchDir, { recursive: true });
       writeFileSync15(filePath, stub);
@@ -8722,14 +9990,6 @@ async function researchAllTechnologies(projectPath, technologies, options) {
   }
   return results;
 }
-function findDocSource(packageName) {
-  for (const source of DOC_SOURCE_REGISTRY) {
-    if (source.packageNames.includes(packageName)) {
-      return source;
-    }
-  }
-  return null;
-}
 async function fetchAndDistill(tech, docSource, fetchFn, maxTokens) {
   const urls = [docSource.docsUrl];
   if (docSource.apiRefUrl && docSource.apiRefUrl !== docSource.docsUrl) {
@@ -8895,7 +10155,7 @@ function generateStubResearch(tech) {
 }
 function readResearchFile(filePath) {
   try {
-    const content = readFileSync20(filePath, "utf-8");
+    const content = readFileSync21(filePath, "utf-8");
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!frontmatterMatch) return null;
     const fm = frontmatterMatch[1] || "";
@@ -8920,16 +10180,16 @@ function readResearchFile(filePath) {
 function getResearchContent(projectPath, technology, version2) {
   const paths = getAgentWorkspacePaths(projectPath);
   if (version2) {
-    const exactPath = join25(paths.researchDir, `${technology}@${version2}.md`);
-    if (existsSync25(exactPath)) {
-      return readFileSync20(exactPath, "utf-8");
+    const exactPath = join26(paths.researchDir, `${technology}@${version2}.md`);
+    if (existsSync26(exactPath)) {
+      return readFileSync21(exactPath, "utf-8");
     }
   }
-  if (existsSync25(paths.researchDir)) {
-    const files = readdirSync7(paths.researchDir);
+  if (existsSync26(paths.researchDir)) {
+    const files = readdirSync8(paths.researchDir);
     const match = files.find((f) => f.startsWith(`${technology}@`));
     if (match) {
-      return readFileSync20(join25(paths.researchDir, match), "utf-8");
+      return readFileSync21(join26(paths.researchDir, match), "utf-8");
     }
   }
   return null;
@@ -8992,114 +10252,12 @@ function htmlToMarkdown(html) {
   text = text.trim();
   return text;
 }
-var DOC_SOURCE_REGISTRY;
 var init_research_engine = __esm({
   "src/core/agents/research-engine.ts"() {
     "use strict";
     init_workspace2();
     init_research_trust();
-    DOC_SOURCE_REGISTRY = [
-      {
-        packageNames: ["express"],
-        docsUrl: "https://expressjs.com/en/api.html",
-        apiRefUrl: "https://expressjs.com/en/4x/api.html",
-        changelogUrl: "https://github.com/expressjs/express/blob/master/History.md"
-      },
-      {
-        packageNames: ["react", "react-dom"],
-        docsUrl: "https://react.dev/reference/react",
-        apiRefUrl: "https://react.dev/reference/react",
-        changelogUrl: "https://github.com/facebook/react/blob/main/CHANGELOG.md"
-      },
-      {
-        packageNames: ["next"],
-        docsUrl: "https://nextjs.org/docs",
-        apiRefUrl: "https://nextjs.org/docs/api-reference",
-        changelogUrl: "https://github.com/vercel/next.js/releases"
-      },
-      {
-        packageNames: ["typescript"],
-        docsUrl: "https://www.typescriptlang.org/docs/",
-        changelogUrl: "https://www.typescriptlang.org/docs/handbook/release-notes/overview.html"
-      },
-      {
-        packageNames: ["vitest"],
-        docsUrl: "https://vitest.dev/api/",
-        apiRefUrl: "https://vitest.dev/api/",
-        changelogUrl: "https://github.com/vitest-dev/vitest/releases"
-      },
-      {
-        packageNames: ["jest"],
-        docsUrl: "https://jestjs.io/docs/api",
-        apiRefUrl: "https://jestjs.io/docs/expect"
-      },
-      {
-        packageNames: ["prisma", "@prisma/client"],
-        docsUrl: "https://www.prisma.io/docs",
-        apiRefUrl: "https://www.prisma.io/docs/reference/api-reference",
-        changelogUrl: "https://github.com/prisma/prisma/releases"
-      },
-      {
-        packageNames: ["stripe"],
-        docsUrl: "https://docs.stripe.com/api",
-        changelogUrl: "https://docs.stripe.com/changelog"
-      },
-      {
-        packageNames: ["@modelcontextprotocol/sdk"],
-        docsUrl: "https://modelcontextprotocol.io/docs",
-        apiRefUrl: "https://github.com/modelcontextprotocol/typescript-sdk"
-      },
-      {
-        packageNames: ["better-sqlite3"],
-        docsUrl: "https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md",
-        apiRefUrl: "https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md"
-      },
-      {
-        packageNames: ["zod"],
-        docsUrl: "https://zod.dev/",
-        apiRefUrl: "https://zod.dev/"
-      },
-      {
-        packageNames: ["tailwindcss"],
-        docsUrl: "https://tailwindcss.com/docs"
-      },
-      {
-        packageNames: ["vite"],
-        docsUrl: "https://vitejs.dev/guide/",
-        apiRefUrl: "https://vitejs.dev/config/"
-      },
-      {
-        packageNames: ["passport"],
-        docsUrl: "https://www.passportjs.org/docs/"
-      },
-      {
-        packageNames: ["jsonwebtoken"],
-        docsUrl: "https://github.com/auth0/node-jsonwebtoken#readme"
-      },
-      {
-        packageNames: ["axios"],
-        docsUrl: "https://axios-http.com/docs/intro",
-        apiRefUrl: "https://axios-http.com/docs/api_intro"
-      },
-      {
-        packageNames: ["fastify"],
-        docsUrl: "https://fastify.dev/docs/latest/",
-        apiRefUrl: "https://fastify.dev/docs/latest/Reference/"
-      },
-      {
-        packageNames: ["drizzle-orm"],
-        docsUrl: "https://orm.drizzle.team/docs/overview"
-      },
-      {
-        packageNames: ["trpc", "@trpc/server", "@trpc/client"],
-        docsUrl: "https://trpc.io/docs"
-      },
-      {
-        packageNames: ["hono"],
-        docsUrl: "https://hono.dev/docs/",
-        apiRefUrl: "https://hono.dev/docs/api/hono"
-      }
-    ];
+    init_universal_inference();
   }
 });
 
@@ -9431,8 +10589,8 @@ var init_diagnosis_table = __esm({
 });
 
 // src/core/agents/improvement-engine.ts
-import { existsSync as existsSync26, readFileSync as readFileSync21, writeFileSync as writeFileSync16, readdirSync as readdirSync8 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync22, writeFileSync as writeFileSync16, readdirSync as readdirSync9 } from "fs";
+import { join as join27 } from "path";
 function learnFromOutcome(db, projectPath, outcome) {
   if (outcome.result === "success") {
     confirmRelatedLessons(projectPath, outcome);
@@ -9602,7 +10760,7 @@ function promoteLessons(db, projectPath) {
   const agentFiles = findAgentFiles(paths);
   const skillFiles = findSkillFiles(paths);
   for (const filePath of agentFiles) {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     if (!content.includes("## Lessons Learned")) continue;
     const lessonsMatch = content.match(/## Lessons Learned\n([\s\S]*?)(?=\n##|\n<!-- |$)/);
     if (!lessonsMatch || !lessonsMatch[1]) continue;
@@ -9614,8 +10772,8 @@ function promoteLessons(db, projectPath) {
       const confirmations = countConfirmations(db, fingerprint);
       if (confirmations >= 3) {
         const featureName = extractFeatureFromPath(filePath);
-        const skillPath = featureName ? join26(paths.featuresDir, featureName, "SKILL.md") : join26(paths.projectDir, "SKILL.md");
-        if (existsSync26(skillPath)) {
+        const skillPath = featureName ? join27(paths.featuresDir, featureName, "SKILL.md") : join27(paths.projectDir, "SKILL.md");
+        if (existsSync27(skillPath)) {
           const ruleAdded = addRuleToSkill(skillPath, lessonContent, config2);
           if (ruleAdded) {
             const updatedContent = content.replace(lesson, `${lesson} [promoted]`);
@@ -9634,9 +10792,9 @@ function diagnoseFailure(failure, db, projectPath) {
   const isInScope = (filePath, agentName) => {
     const paths = getAgentWorkspacePaths(projectPath);
     const name = agentName.replace(/-agent$/, "");
-    const agentPath = join26(paths.featuresDir, name, "AGENT.md");
-    if (!existsSync26(agentPath)) return true;
-    const agentContent = readFileSync21(agentPath, "utf-8");
+    const agentPath = join27(paths.featuresDir, name, "AGENT.md");
+    if (!existsSync27(agentPath)) return true;
+    const agentContent = readFileSync22(agentPath, "utf-8");
     return fileMatchesAgentScope(filePath, agentContent);
   };
   const ctx = {
@@ -9662,10 +10820,10 @@ function fileMatchesAgentScope(filePath, agentMdContent) {
 function patchSkillWithFix(projectPath, outcome, diagnosis, config2) {
   const paths = getAgentWorkspacePaths(projectPath);
   const agentName = outcome.agent.replace(/-agent$/, "");
-  const featureSkillPath = join26(paths.featuresDir, agentName, "SKILL.md");
-  const targetPath = existsSync26(featureSkillPath) ? featureSkillPath : join26(paths.projectDir, "SKILL.md");
-  if (!existsSync26(targetPath)) return null;
-  const content = readFileSync21(targetPath, "utf-8");
+  const featureSkillPath = join27(paths.featuresDir, agentName, "SKILL.md");
+  const targetPath = existsSync27(featureSkillPath) ? featureSkillPath : join27(paths.projectDir, "SKILL.md");
+  if (!existsSync27(targetPath)) return null;
+  const content = readFileSync22(targetPath, "utf-8");
   const pitfallEntry = `- ${diagnosis.description.slice(0, 150)} \u2192 Fix: ${outcome.fixApplied.slice(0, 100)}`;
   if (!content.includes(config2.markers.start)) return null;
   const startIdx = content.indexOf(config2.markers.start);
@@ -9708,9 +10866,9 @@ function identifyAffectedTechnologies(outcome, projectPath) {
       techs.push(pkg);
     }
   }
-  if (existsSync26(paths.researchDir)) {
+  if (existsSync27(paths.researchDir)) {
     try {
-      const researchFiles = readdirSync8(paths.researchDir);
+      const researchFiles = readdirSync9(paths.researchDir);
       for (const file2 of researchFiles) {
         const techName = file2.replace(/@.*\.md$/, "");
         if (outcome.errorMessage && outcome.errorMessage.toLowerCase().includes(techName.toLowerCase())) {
@@ -9733,9 +10891,9 @@ function confirmRelatedLessons(projectPath, outcome) {
   if (outcome.relatedSkills.length === 0) return;
   const paths = getAgentWorkspacePaths(projectPath);
   const agentName = outcome.agent.replace(/-agent$/, "");
-  const agentPath = join26(paths.featuresDir, agentName, "AGENT.md");
-  if (!existsSync26(agentPath)) return;
-  const content = readFileSync21(agentPath, "utf-8");
+  const agentPath = join27(paths.featuresDir, agentName, "AGENT.md");
+  if (!existsSync27(agentPath)) return;
+  const content = readFileSync22(agentPath, "utf-8");
   const taskWords = outcome.task.toLowerCase().split(/\W+/).filter((w) => w.length > 3);
   let updated = content;
   let changed = false;
@@ -9763,28 +10921,28 @@ function writeLesson(projectPath, failure, diagnosis, config2) {
       return null;
     case "scope-error": {
       const agentName = failure.agent.replace(/-agent$/, "");
-      targetPath = join26(paths.featuresDir, agentName, "AGENT.md");
+      targetPath = join27(paths.featuresDir, agentName, "AGENT.md");
       break;
     }
     case "wrong-assumption":
     case "missing-test": {
       const agentName = failure.agent.replace(/-agent$/, "");
-      const featurePath = join26(paths.featuresDir, agentName, "AGENT.md");
-      targetPath = existsSync26(featurePath) ? featurePath : join26(paths.projectDir, "AGENT.md");
+      const featurePath = join27(paths.featuresDir, agentName, "AGENT.md");
+      targetPath = existsSync27(featurePath) ? featurePath : join27(paths.projectDir, "AGENT.md");
       break;
     }
     case "missing-convention":
-      targetPath = join26(paths.projectDir, "AGENT.md");
+      targetPath = join27(paths.projectDir, "AGENT.md");
       break;
     case "external-change":
     default:
-      targetPath = join26(paths.projectDir, "AGENT.md");
+      targetPath = join27(paths.projectDir, "AGENT.md");
       break;
   }
-  if (!existsSync26(targetPath)) return null;
+  if (!existsSync27(targetPath)) return null;
   const evidenceRef = failure.fixApplied ? ` Fix: ${failure.fixApplied.slice(0, 80)}` : "";
   const lessonText = `- ${today}: ${diagnosis.description.slice(0, 200)}${evidenceRef} (outcome: ${failure.id.slice(0, 8)})`;
-  const existing = readFileSync21(targetPath, "utf-8");
+  const existing = readFileSync22(targetPath, "utf-8");
   const fingerprint = computeErrorFingerprint(diagnosis.description);
   if (existing.includes(fingerprint.slice(0, 30))) {
     return null;
@@ -9807,7 +10965,7 @@ function writeLesson(projectPath, failure, diagnosis, config2) {
   return targetPath;
 }
 function addRuleToSkill(skillPath, ruleContent, config2) {
-  const content = readFileSync21(skillPath, "utf-8");
+  const content = readFileSync22(skillPath, "utf-8");
   if (!content.includes(config2.markers.start)) return false;
   const startIdx = content.indexOf(config2.markers.start);
   const endIdx = content.indexOf(config2.markers.end);
@@ -9885,7 +11043,7 @@ function decayOldLessons(projectPath, maxAgeDays = 90) {
   const cutoff = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
   const agentFiles = findAgentFiles(paths);
   for (const filePath of agentFiles) {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     if (!content.includes(config2.markers.start)) continue;
     const updated = content.replace(
       /^(- \d{4}-\d{2}-\d{2}: .+?)(?<!\[unconfirmed\])(?<!\[confirmed\])(?<!\[promoted\])$/gm,
@@ -9906,14 +11064,14 @@ function decayOldLessons(projectPath, maxAgeDays = 90) {
 }
 function findAgentFiles(paths) {
   const files = [];
-  const superAgent = join26(paths.projectDir, "AGENT.md");
-  if (existsSync26(superAgent)) files.push(superAgent);
-  if (existsSync26(paths.featuresDir)) {
+  const superAgent = join27(paths.projectDir, "AGENT.md");
+  if (existsSync27(superAgent)) files.push(superAgent);
+  if (existsSync27(paths.featuresDir)) {
     try {
-      const features = readdirSync8(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const features = readdirSync9(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       for (const feature of features) {
-        const agentPath = join26(paths.featuresDir, feature, "AGENT.md");
-        if (existsSync26(agentPath)) files.push(agentPath);
+        const agentPath = join27(paths.featuresDir, feature, "AGENT.md");
+        if (existsSync27(agentPath)) files.push(agentPath);
       }
     } catch {
     }
@@ -9922,14 +11080,14 @@ function findAgentFiles(paths) {
 }
 function findSkillFiles(paths) {
   const files = [];
-  const projectSkill = join26(paths.projectDir, "SKILL.md");
-  if (existsSync26(projectSkill)) files.push(projectSkill);
-  if (existsSync26(paths.featuresDir)) {
+  const projectSkill = join27(paths.projectDir, "SKILL.md");
+  if (existsSync27(projectSkill)) files.push(projectSkill);
+  if (existsSync27(paths.featuresDir)) {
     try {
-      const features = readdirSync8(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const features = readdirSync9(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       for (const feature of features) {
-        const skillPath = join26(paths.featuresDir, feature, "SKILL.md");
-        if (existsSync26(skillPath)) files.push(skillPath);
+        const skillPath = join27(paths.featuresDir, feature, "SKILL.md");
+        if (existsSync27(skillPath)) files.push(skillPath);
       }
     } catch {
     }
@@ -10082,8 +11240,8 @@ var init_telemetry = __esm({
 });
 
 // src/core/agents/tech-detector.ts
-import { existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
+import { join as join30 } from "path";
 function detectTechnologies(projectPath) {
   const technologies = [];
   const seen = /* @__PURE__ */ new Set();
@@ -10111,23 +11269,23 @@ function detectTechnologies(projectPath) {
   return technologies;
 }
 function detectFromLockfiles(projectPath) {
-  const npmLock = join29(projectPath, "package-lock.json");
-  if (existsSync28(npmLock)) {
+  const npmLock = join30(projectPath, "package-lock.json");
+  if (existsSync29(npmLock)) {
     return parsePackageLock(npmLock);
   }
-  const pnpmLock = join29(projectPath, "pnpm-lock.yaml");
-  if (existsSync28(pnpmLock)) {
+  const pnpmLock = join30(projectPath, "pnpm-lock.yaml");
+  if (existsSync29(pnpmLock)) {
     return parsePnpmLock(pnpmLock);
   }
-  const yarnLock = join29(projectPath, "yarn.lock");
-  if (existsSync28(yarnLock)) {
+  const yarnLock = join30(projectPath, "yarn.lock");
+  if (existsSync29(yarnLock)) {
     return parseYarnLock(yarnLock);
   }
   return [];
 }
 function parsePackageLock(lockPath) {
   try {
-    const content = JSON.parse(readFileSync23(lockPath, "utf-8"));
+    const content = JSON.parse(readFileSync24(lockPath, "utf-8"));
     const techs = [];
     if (content.packages) {
       for (const [key, pkg] of Object.entries(content.packages)) {
@@ -10162,7 +11320,7 @@ function parsePackageLock(lockPath) {
 }
 function parsePnpmLock(lockPath) {
   try {
-    const content = readFileSync23(lockPath, "utf-8");
+    const content = readFileSync24(lockPath, "utf-8");
     const techs = [];
     const packageRegex = /^\s*[/'"]?(@?[^@\s'":]+)@(\d+\.\d+\.\d+[^'":]*)/gm;
     let match;
@@ -10187,7 +11345,7 @@ function parsePnpmLock(lockPath) {
 }
 function parseYarnLock(lockPath) {
   try {
-    const content = readFileSync23(lockPath, "utf-8");
+    const content = readFileSync24(lockPath, "utf-8");
     const techs = [];
     const seen = /* @__PURE__ */ new Set();
     const lines = content.split("\n");
@@ -10221,10 +11379,10 @@ function parseYarnLock(lockPath) {
 }
 function detectFromManifests(projectPath) {
   const techs = [];
-  const pkgPath = join29(projectPath, "package.json");
-  if (existsSync28(pkgPath)) {
+  const pkgPath = join30(projectPath, "package.json");
+  if (existsSync29(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync23(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync24(pkgPath, "utf-8"));
       const allDeps = {
         ...pkg.dependencies,
         ...pkg.devDependencies
@@ -10239,10 +11397,10 @@ function detectFromManifests(projectPath) {
     } catch {
     }
   }
-  const reqPath = join29(projectPath, "requirements.txt");
-  if (existsSync28(reqPath)) {
+  const reqPath = join30(projectPath, "requirements.txt");
+  if (existsSync29(reqPath)) {
     try {
-      const content = readFileSync23(reqPath, "utf-8");
+      const content = readFileSync24(reqPath, "utf-8");
       for (const line of content.split("\n")) {
         const match = line.match(/^([a-zA-Z0-9_-]+)==([^\s]+)/);
         if (match && match[1] && match[2]) {
@@ -10252,10 +11410,10 @@ function detectFromManifests(projectPath) {
     } catch {
     }
   }
-  const goModPath = join29(projectPath, "go.mod");
-  if (existsSync28(goModPath)) {
+  const goModPath = join30(projectPath, "go.mod");
+  if (existsSync29(goModPath)) {
     try {
-      const content = readFileSync23(goModPath, "utf-8");
+      const content = readFileSync24(goModPath, "utf-8");
       const reqRegex = /^\s+([^\s]+)\s+v([^\s]+)/gm;
       let match;
       while ((match = reqRegex.exec(content)) !== null) {
@@ -10266,10 +11424,10 @@ function detectFromManifests(projectPath) {
     } catch {
     }
   }
-  const cargoPath = join29(projectPath, "Cargo.toml");
-  if (existsSync28(cargoPath)) {
+  const cargoPath = join30(projectPath, "Cargo.toml");
+  if (existsSync29(cargoPath)) {
     try {
-      const content = readFileSync23(cargoPath, "utf-8");
+      const content = readFileSync24(cargoPath, "utf-8");
       const depRegex = /^([a-zA-Z0-9_-]+)\s*=\s*"([^"]+)"/gm;
       let match;
       let inDeps = false;
@@ -10297,12 +11455,12 @@ function detectFromManifests(projectPath) {
 function detectFromConfigFiles(projectPath) {
   const techs = [];
   for (const detection of CONFIG_DETECTIONS) {
-    const filePath = join29(projectPath, detection.file);
-    if (existsSync28(filePath)) {
+    const filePath = join30(projectPath, detection.file);
+    if (existsSync29(filePath)) {
       let version2 = "detected";
       if (detection.versionExtractor) {
         try {
-          const content = readFileSync23(filePath, "utf-8");
+          const content = readFileSync24(filePath, "utf-8");
           version2 = detection.versionExtractor(content) || "detected";
         } catch {
         }
@@ -10317,43 +11475,43 @@ function detectFromConfigFiles(projectPath) {
   return techs;
 }
 function detectMonorepo(projectPath) {
-  const pnpmWorkspace = join29(projectPath, "pnpm-workspace.yaml");
-  if (existsSync28(pnpmWorkspace)) {
-    const content = readFileSync23(pnpmWorkspace, "utf-8");
+  const pnpmWorkspace = join30(projectPath, "pnpm-workspace.yaml");
+  if (existsSync29(pnpmWorkspace)) {
+    const content = readFileSync24(pnpmWorkspace, "utf-8");
     const packages = extractWorkspacePatterns(content);
     return { type: "pnpm", packages, rootPath: projectPath };
   }
-  if (existsSync28(join29(projectPath, "turbo.json"))) {
-    const pkgJson = join29(projectPath, "package.json");
+  if (existsSync29(join30(projectPath, "turbo.json"))) {
+    const pkgJson = join30(projectPath, "package.json");
     let packages = [];
-    if (existsSync28(pkgJson)) {
+    if (existsSync29(pkgJson)) {
       try {
-        const pkg = JSON.parse(readFileSync23(pkgJson, "utf-8"));
+        const pkg = JSON.parse(readFileSync24(pkgJson, "utf-8"));
         packages = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages || [];
       } catch {
       }
     }
     return { type: "turborepo", packages, rootPath: projectPath };
   }
-  const pkgPath = join29(projectPath, "package.json");
-  if (existsSync28(pkgPath)) {
+  const pkgPath = join30(projectPath, "package.json");
+  if (existsSync29(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync23(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync24(pkgPath, "utf-8"));
       if (pkg.workspaces) {
         const patterns = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || [];
-        const type = existsSync28(join29(projectPath, "yarn.lock")) ? "yarn-workspaces" : "npm-workspaces";
+        const type = existsSync29(join30(projectPath, "yarn.lock")) ? "yarn-workspaces" : "npm-workspaces";
         return { type, packages: patterns, rootPath: projectPath };
       }
     } catch {
     }
   }
-  if (existsSync28(join29(projectPath, "nx.json"))) {
+  if (existsSync29(join30(projectPath, "nx.json"))) {
     return { type: "nx", packages: ["packages/*", "apps/*"], rootPath: projectPath };
   }
-  const lernaPath = join29(projectPath, "lerna.json");
-  if (existsSync28(lernaPath)) {
+  const lernaPath = join30(projectPath, "lerna.json");
+  if (existsSync29(lernaPath)) {
     try {
-      const lerna = JSON.parse(readFileSync23(lernaPath, "utf-8"));
+      const lerna = JSON.parse(readFileSync24(lernaPath, "utf-8"));
       return { type: "lerna", packages: lerna.packages || ["packages/*"], rootPath: projectPath };
     } catch {
     }
@@ -10418,8 +11576,8 @@ var init_tech_detector = __esm({
 });
 
 // src/core/agents/feature-detector.ts
-import { existsSync as existsSync29, readFileSync as readFileSync24, readdirSync as readdirSync10 } from "fs";
-import { join as join30, relative as relative7, basename as basename10 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync25, readdirSync as readdirSync11 } from "fs";
+import { join as join31, relative as relative7, basename as basename10 } from "path";
 function detectFeatures(input) {
   const { projectPath, config: config2, importGraph, indexedFiles, fileTechMap } = input;
   let candidates = [];
@@ -10480,15 +11638,15 @@ function findSubPackageJsons(projectPath) {
   function walk(dir, depth) {
     if (depth > maxDepth) return;
     try {
-      const entries = readdirSync10(dir, { withFileTypes: true });
+      const entries = readdirSync11(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const lower = entry.name.toLowerCase();
         if (lower === "node_modules" || lower === ".git" || lower === "dist") continue;
         if (EXCLUDED_FEATURE_DIRS.has(lower)) continue;
-        const subDir = join30(dir, entry.name);
-        const pkgJson = join30(subDir, "package.json");
-        if (existsSync29(pkgJson) && subDir !== projectPath) {
+        const subDir = join31(dir, entry.name);
+        const pkgJson = join31(subDir, "package.json");
+        if (existsSync30(pkgJson) && subDir !== projectPath) {
           results.push(subDir);
         }
         walk(subDir, depth + 1);
@@ -10502,20 +11660,20 @@ function findSubPackageJsons(projectPath) {
 function detectCodeownerFeatures(projectPath, indexedFiles) {
   const features = [];
   const codeownersLocations = [
-    join30(projectPath, "CODEOWNERS"),
-    join30(projectPath, ".github", "CODEOWNERS"),
-    join30(projectPath, "docs", "CODEOWNERS")
+    join31(projectPath, "CODEOWNERS"),
+    join31(projectPath, ".github", "CODEOWNERS"),
+    join31(projectPath, "docs", "CODEOWNERS")
   ];
   let codeownersPath = null;
   for (const loc of codeownersLocations) {
-    if (existsSync29(loc)) {
+    if (existsSync30(loc)) {
       codeownersPath = loc;
       break;
     }
   }
   if (!codeownersPath) return features;
   try {
-    const content = readFileSync24(codeownersPath, "utf-8");
+    const content = readFileSync25(codeownersPath, "utf-8");
     const entries = parseCodeowners(content);
     for (const entry of entries) {
       const matchingFiles = indexedFiles.filter((f) => matchCodeownerPattern(f, entry.pattern));
@@ -10787,8 +11945,8 @@ var init_feature_detector = __esm({
 
 // src/core/agents/git-operations.ts
 import { execSync as execSync9 } from "child_process";
-import { existsSync as existsSync30 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync31 } from "fs";
+import { join as join32 } from "path";
 function isGitRepo(projectPath) {
   try {
     git(projectPath, "rev-parse --is-inside-work-tree");
@@ -10830,7 +11988,7 @@ function commitChanges(projectPath, options) {
       }
     } else {
       git(projectPath, "add .code-impact/");
-      if (existsSync30(join31(projectPath, "AGENTS.md"))) {
+      if (existsSync31(join32(projectPath, "AGENTS.md"))) {
         git(projectPath, "add AGENTS.md");
       }
     }
@@ -10950,7 +12108,7 @@ var init_git_operations = __esm({
 });
 
 // src/core/agents/marker-writer.ts
-import { existsSync as existsSync31, readFileSync as readFileSync25, writeFileSync as writeFileSync18, mkdirSync as mkdirSync16 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync26, writeFileSync as writeFileSync18, mkdirSync as mkdirSync16 } from "fs";
 import { dirname as dirname13 } from "path";
 function writeMarkedFile(filePath, frontmatter, sections, options) {
   const result = {
@@ -10970,8 +12128,8 @@ function writeMarkedFile(filePath, frontmatter, sections, options) {
     result.tokenCount = estimateTokens5(autoContent);
     return result;
   }
-  if (existsSync31(filePath)) {
-    const existing = readFileSync25(filePath, "utf-8");
+  if (existsSync32(filePath)) {
+    const existing = readFileSync26(filePath, "utf-8");
     if (existing.includes(options.markers.start)) {
       const existingAutoContent = extractAutoContent(existing, options.markers);
       const existingHash = computeContentHash(existingAutoContent);
@@ -11192,19 +12350,19 @@ var init_token_budget = __esm({
 });
 
 // src/core/agents/generator.ts
-import { existsSync as existsSync32, readFileSync as readFileSync26, mkdirSync as mkdirSync17 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync27, mkdirSync as mkdirSync17 } from "fs";
+import { join as join34 } from "path";
 function generateProjectFiles(input) {
   const { projectPath, intelligence, technologies, features, index } = input;
   const config2 = readAgentConfig(projectPath);
   const paths = getAgentWorkspacePaths(projectPath);
   const result = { filesWritten: [], filesSkipped: [] };
   mkdirSync17(paths.projectDir, { recursive: true });
-  const skillPath = join33(paths.projectDir, "SKILL.md");
+  const skillPath = join34(paths.projectDir, "SKILL.md");
   writeMarkedFile2(skillPath, renderProjectSkill(intelligence, technologies, config2, projectPath), config2, result, "project_skill");
-  const convPath = join33(paths.projectDir, "CONVENTIONS.md");
+  const convPath = join34(paths.projectDir, "CONVENTIONS.md");
   writeMarkedFile2(convPath, renderConventions(intelligence, config2), config2, result, "project_conventions");
-  const archPath = join33(paths.projectDir, "ARCHITECTURE.md");
+  const archPath = join34(paths.projectDir, "ARCHITECTURE.md");
   writeMarkedFile2(archPath, renderArchitecture(intelligence, config2), config2, result, "project_architecture");
   return result;
 }
@@ -11214,9 +12372,9 @@ function generateFeatureFiles(input) {
   const paths = getAgentWorkspacePaths(projectPath);
   const result = { filesWritten: [], filesSkipped: [] };
   for (const feature of features) {
-    const featureDir = join33(paths.featuresDir, feature.name);
+    const featureDir = join34(paths.featuresDir, feature.name);
     mkdirSync17(featureDir, { recursive: true });
-    const skillPath = join33(featureDir, "SKILL.md");
+    const skillPath = join34(featureDir, "SKILL.md");
     const featureTechs = technologies.filter((t) => feature.technologies.includes(t.name));
     writeMarkedFile2(skillPath, renderFeatureSkill(feature, featureTechs, config2), config2, result, "feature_skill");
   }
@@ -11274,7 +12432,7 @@ function renderProjectSkill(intel, technologies, config2, projectPath) {
   } else {
     for (const dir of intel.codebase.keyDirectories) {
       const dirName = dir.split("/").pop() || dir;
-      const purpose = inferDirPurpose(dirName);
+      const purpose = inferDirectoryPurpose(dirName);
       lines.push(`| ${dir}/ | ${purpose} |`);
     }
   }
@@ -11376,8 +12534,10 @@ function renderArchitecture(intel, config2) {
   return { frontmatter, autoContent: lines.join("\n") };
 }
 function renderFeatureSkill(feature, technologies, config2) {
-  const techNames = technologies.map((t) => t.name);
-  const researchRefs = technologies.map((t) => `research/${t.name}@${t.version}.md`);
+  const grouped = groupScopedPackages(technologies);
+  const techNames = grouped.map((t) => t.name);
+  const researchTechs = technologies.slice(0, 15);
+  const researchRefs = researchTechs.map((t) => `research/${t.name}@${t.version}.md`);
   const frontmatter = [
     "---",
     `name: ${feature.name}-feature`,
@@ -11390,7 +12550,7 @@ function renderFeatureSkill(feature, technologies, config2) {
     `  research_refs: [${researchRefs.join(", ")}]`,
     "---",
     "",
-    `# ${capitalize(feature.name)} Feature`
+    `# ${capitalize2(feature.name)} Feature`
   ].join("\n");
   const lines = [];
   lines.push("## Scope");
@@ -11410,14 +12570,16 @@ function renderFeatureSkill(feature, technologies, config2) {
   if (feature.owner) {
     lines.push(`- Owner: ${feature.owner}`);
   }
-  if (technologies.length > 0) {
-    lines.push(`- Technologies: ${techNames.join(", ")}`);
+  if (grouped.length > 0) {
+    const displayTechs = techNames.slice(0, 10);
+    const suffix = techNames.length > 10 ? `, +${techNames.length - 10} more` : "";
+    lines.push(`- Technologies: ${displayTechs.join(", ")}${suffix}`);
   }
   lines.push("");
   if (researchRefs.length > 0) {
     lines.push("## Research References");
     for (const ref of researchRefs) {
-      const tech = technologies.find((t) => ref.includes(t.name));
+      const tech = researchTechs.find((t) => ref.includes(t.name));
       if (tech) {
         lines.push(`- [${tech.name} v${tech.version}](../${ref})`);
       }
@@ -11425,13 +12587,13 @@ function renderFeatureSkill(feature, technologies, config2) {
     lines.push("");
   }
   lines.push("## Rules");
-  const rules = deriveRules(feature, technologies);
+  const rules = deriveFeatureRules(feature, technologies);
   for (const rule of rules) {
     lines.push(`- ${rule}`);
   }
   lines.push("");
   lines.push("## Pitfalls");
-  const pitfalls = derivePitfalls(feature, technologies);
+  const pitfalls = deriveFeaturePitfalls(feature, technologies);
   for (const pitfall of pitfalls) {
     lines.push(`- ${pitfall}`);
   }
@@ -11502,150 +12664,7 @@ function summarizeTestFiles(testFiles) {
   }
   return globs;
 }
-function inferDirPurpose(dirName) {
-  const purposes = {
-    core: "Core business logic and domain modules",
-    server: "Server, transports, and request handling",
-    storage: "Database access and persistence",
-    indexing: "Code indexing and symbol extraction",
-    api: "API routes and handlers",
-    auth: "Authentication and authorization",
-    billing: "Payment processing",
-    test: "Tests and evaluation harness",
-    doc: "Documentation",
-    knowledge: "AI knowledge system",
-    cli: "Command-line interface",
-    base: "Base configuration and fixtures",
-    src: "Application source code",
-    lib: "Shared utilities"
-  };
-  return purposes[dirName.toLowerCase()] || `${dirName} module`;
-}
-function deriveRules(feature, technologies) {
-  const rules = [];
-  if (WELL_KNOWN_FEATURES.has(feature.name)) {
-    rules.push(...getFeatureNameRules(feature.name));
-    const techRules = [];
-    for (const tech of technologies) {
-      const knowledge = TECH_KNOWLEDGE[tech.name];
-      if (knowledge) techRules.push(...knowledge.rules);
-    }
-    for (const tr of techRules.slice(0, 2)) {
-      if (!rules.some((r) => r.includes(tr.split(" ")[0] || ""))) {
-        rules.push(tr);
-      }
-    }
-  } else {
-    for (const tech of technologies) {
-      const knowledge = TECH_KNOWLEDGE[tech.name];
-      if (knowledge) rules.push(...knowledge.rules);
-    }
-    if (rules.length === 0) {
-      rules.push(...getFeatureNameRules(feature.name));
-    }
-  }
-  if (feature.paths.length > 0) {
-    const scope = feature.paths[0]?.replace("/**", "") || "";
-    rules.push(`Changes here should not import from other feature directories \u2014 keep ${scope} self-contained`);
-  }
-  return rules;
-}
-function derivePitfalls(feature, technologies) {
-  const pitfalls = [];
-  if (WELL_KNOWN_FEATURES.has(feature.name)) {
-    pitfalls.push(...getFeatureNamePitfalls(feature.name));
-    for (const tech of technologies) {
-      const knowledge = TECH_KNOWLEDGE[tech.name];
-      if (knowledge) {
-        for (const p of knowledge.pitfalls.slice(0, 1)) {
-          if (!pitfalls.includes(p)) pitfalls.push(p);
-        }
-      }
-    }
-  } else {
-    for (const tech of technologies) {
-      const knowledge = TECH_KNOWLEDGE[tech.name];
-      if (knowledge) pitfalls.push(...knowledge.pitfalls);
-    }
-    if (pitfalls.length === 0) {
-      pitfalls.push(...getFeatureNamePitfalls(feature.name));
-    }
-  }
-  return pitfalls;
-}
-function getFeatureNameRules(name) {
-  const rules = {
-    server: [
-      "All tool/resource handlers must validate inputs before processing",
-      "Return structured error responses \u2014 never throw raw errors to clients"
-    ],
-    storage: [
-      "All database access should go through this module \u2014 no direct imports elsewhere",
-      "Use transactions for multi-step operations to ensure consistency"
-    ],
-    indexing: [
-      "Index operations should be idempotent \u2014 reindexing same file produces same result",
-      "Handle parse errors gracefully \u2014 a broken file should not crash the indexer"
-    ],
-    core: [
-      "Core modules should have no side effects on import",
-      "Export types alongside functions for downstream consumers"
-    ],
-    test: [
-      "Tests should be deterministic \u2014 no reliance on external services or timing",
-      "Clean up temporary files and directories in afterEach/afterAll hooks"
-    ],
-    knowledge: [
-      "Skill files must follow the agentskills.io SKILL.md format",
-      "Generated content must use marker comments to preserve manual edits"
-    ],
-    doc: [
-      "Generated docs must be kept in sync with source code changes",
-      "Use relative paths for internal links"
-    ],
-    auth: [
-      "Never store plain-text passwords \u2014 use bcrypt or argon2",
-      "Validate and sanitize all user inputs before processing"
-    ],
-    api: [
-      "All endpoints must validate request bodies/params before processing",
-      "Return consistent error response shapes across all endpoints"
-    ]
-  };
-  return rules[name] || [
-    "Follow existing patterns in this module for consistency",
-    "Export public API from index.ts \u2014 keep internal helpers unexported"
-  ];
-}
-function getFeatureNamePitfalls(name) {
-  const pitfalls = {
-    server: [
-      "Unhandled promise rejections in handlers crash the process \u2014 always catch async errors",
-      "Adding middleware order matters \u2014 auth before route handlers"
-    ],
-    storage: [
-      "Forgetting to close database connections leaks file handles",
-      "Concurrent writes without transactions may cause data corruption"
-    ],
-    indexing: [
-      "Large files can cause out-of-memory \u2014 set size limits on parsed content",
-      "File paths must be normalized (forward slashes) for cross-platform compatibility"
-    ],
-    core: [
-      "Circular imports between core modules cause runtime errors \u2014 check dependency direction",
-      "Changing public API signatures breaks downstream consumers"
-    ],
-    test: [
-      "Tests sharing mutable state between runs cause flaky failures",
-      "Temp directories not cleaned up fill disk over repeated test runs"
-    ]
-  };
-  return pitfalls[name] || [
-    "Check for null/undefined before property access on external data",
-    "Changing exports may break other modules that depend on this feature"
-  ];
-}
-function capitalize(str) {
+function capitalize2(str) {
   return str.charAt(0).toUpperCase() + str.slice(1).replace(/-/g, " ");
 }
 function filterDirectDependencies(technologies, projectPath) {
@@ -11657,13 +12676,13 @@ function filterDirectDependencies(technologies, projectPath) {
   }
   if (directNames.size === 0) {
     const searchPaths = [
-      projectPath ? join33(projectPath, "package.json") : "",
-      join33(process.cwd(), "package.json")
+      projectPath ? join34(projectPath, "package.json") : "",
+      join34(process.cwd(), "package.json")
     ].filter(Boolean);
     for (const p of searchPaths) {
       try {
-        if (existsSync32(p)) {
-          const pkg = JSON.parse(readFileSync26(p, "utf-8"));
+        if (existsSync33(p)) {
+          const pkg = JSON.parse(readFileSync27(p, "utf-8"));
           for (const d of Object.keys(pkg.dependencies || {})) directNames.add(d);
           for (const d of Object.keys(pkg.devDependencies || {})) directNames.add(d);
           break;
@@ -11680,151 +12699,50 @@ function filterDirectDependencies(technologies, projectPath) {
     /^@parcel\//,
     /^@biomejs\//
   ];
+  let filtered;
   if (directNames.size > 0) {
-    return technologies.filter((t) => directNames.has(t.name)).filter((t) => !skipPatterns.some((p) => p.test(t.name)));
+    filtered = technologies.filter((t) => directNames.has(t.name)).filter((t) => !skipPatterns.some((p) => p.test(t.name)));
+  } else {
+    filtered = technologies.filter((t) => !skipPatterns.some((p) => p.test(t.name))).slice(0, 30);
+  }
+  return groupScopedPackages(filtered);
+}
+function groupScopedPackages(techs) {
+  const scopeMap = /* @__PURE__ */ new Map();
+  const ungrouped = [];
+  for (const t of techs) {
+    const m = t.name.match(/^(@[^/]+)\//);
+    if (m) {
+      const scope = m[1];
+      if (!scopeMap.has(scope)) scopeMap.set(scope, []);
+      scopeMap.get(scope).push(t);
+    } else {
+      ungrouped.push(t);
+    }
+  }
+  const result = [...ungrouped];
+  for (const [scope, members] of scopeMap.entries()) {
+    if (members.length >= 3) {
+      const label = inferScopeLabel(scope, members.length);
+      result.push({
+        name: label,
+        version: members[0].version,
+        source: members[0].source,
+        importPaths: members.flatMap((m) => m.importPaths || [])
+      });
+    } else {
+      result.push(...members);
+    }
   }
-  return technologies.filter((t) => !skipPatterns.some((p) => p.test(t.name))).slice(0, 20);
+  return result;
 }
-var TECH_KNOWLEDGE, WELL_KNOWN_FEATURES;
 var init_generator = __esm({
   "src/core/agents/generator.ts"() {
     "use strict";
     init_workspace2();
     init_marker_writer();
     init_token_budget();
-    TECH_KNOWLEDGE = {
-      "express": {
-        rules: [
-          "Use Router() for modular route definitions",
-          "Always register error handler middleware last (4 args: err, req, res, next)"
-        ],
-        pitfalls: [
-          "Forgetting to call next() in middleware causes request to hang",
-          "Async errors in handlers need explicit try/catch or express-async-errors"
-        ]
-      },
-      "hono": {
-        rules: [
-          "Use app.route() for modular route grouping",
-          "Return c.json() or c.text() \u2014 do not use res.send()"
-        ],
-        pitfalls: [
-          "Hono middleware must call next() or return a Response \u2014 skipping both hangs the request"
-        ]
-      },
-      "better-sqlite3": {
-        rules: [
-          "Use db.prepare().all() for SELECT, db.prepare().run() for INSERT/UPDATE/DELETE",
-          "better-sqlite3 is synchronous \u2014 do NOT use async/await with db calls",
-          "All database access should go through a single module"
-        ],
-        pitfalls: [
-          "db.exec() returns nothing \u2014 using it for SELECT gives undefined",
-          'WAL mode must be set once after opening: db.pragma("journal_mode = WAL")'
-        ]
-      },
-      "stripe": {
-        rules: [
-          "Always verify webhook signatures before processing events",
-          "Use idempotency keys for payment creation to prevent double-charges"
-        ],
-        pitfalls: [
-          "Stripe webhook events may arrive out of order \u2014 handle idempotently",
-          "stripe.webhooks.constructEvent() throws on invalid signature \u2014 wrap in try/catch"
-        ]
-      },
-      "jsonwebtoken": {
-        rules: [
-          "Always use jwt.verify() \u2014 never trust jwt.decode() alone",
-          "Set explicit expiration (expiresIn) on all tokens"
-        ],
-        pitfalls: [
-          "Using jwt.decode() without verify() is a security vulnerability",
-          'The "none" algorithm attack \u2014 always specify algorithms: ["HS256"]'
-        ]
-      },
-      "@modelcontextprotocol/sdk": {
-        rules: [
-          "Use server.tool() to register MCP tools with zod schema validation",
-          "All tool handlers must return { content: [...] } response objects"
-        ],
-        pitfalls: [
-          "Tool names must be unique across the server \u2014 duplicates silently overwrite",
-          "Forgetting to call server.connect(transport) means no requests are handled"
-        ]
-      },
-      "prisma": {
-        rules: [
-          "Run npx prisma generate after schema changes",
-          "Use transactions for multi-table operations: prisma.$transaction()"
-        ],
-        pitfalls: [
-          "Forgetting prisma generate after schema change causes type mismatches at runtime",
-          "N+1 queries \u2014 use include/select to eagerly load relations"
-        ]
-      },
-      "zod": {
-        rules: [
-          "Define schemas once, derive TypeScript types with z.infer<typeof schema>",
-          "Use .safeParse() in handlers for graceful error handling"
-        ],
-        pitfalls: [
-          ".parse() throws on invalid data \u2014 use .safeParse() in request handlers"
-        ]
-      },
-      "vitest": {
-        rules: [
-          "Use describe/it/expect patterns for test organization",
-          "Use vi.mock() for module mocking, vi.fn() for function stubs"
-        ],
-        pitfalls: [
-          "vi.mock() is hoisted to top of file \u2014 cannot access variables from outer scope"
-        ]
-      },
-      "web-tree-sitter": {
-        rules: [
-          "Initialize Parser with await Parser.init() before use",
-          "Load language WASM files with Parser.Language.load()"
-        ],
-        pitfalls: [
-          "Parser.init() must complete before any parsing \u2014 race condition if not awaited",
-          "WASM files must be bundled/copied to dist \u2014 not resolved from node_modules at runtime"
-        ]
-      },
-      "@xenova/transformers": {
-        rules: [
-          "Use pipeline() for high-level tasks, AutoModel for custom inference",
-          "Cache downloaded models by setting env.cacheDir"
-        ],
-        pitfalls: [
-          "First model load downloads weights (~100MB+) \u2014 cache for subsequent runs",
-          "ONNX runtime may fail on some architectures \u2014 test on target platform"
-        ]
-      },
-      "chokidar": {
-        rules: [
-          "Use chokidar.watch() with ignored patterns to skip node_modules",
-          'Handle both "add" and "change" events for file watching'
-        ],
-        pitfalls: [
-          "Not closing watcher on process exit leaks file handles",
-          "Rapid file changes may fire multiple events \u2014 debounce handlers"
-        ]
-      }
-    };
-    WELL_KNOWN_FEATURES = /* @__PURE__ */ new Set([
-      "server",
-      "storage",
-      "indexing",
-      "core",
-      "test",
-      "knowledge",
-      "doc",
-      "auth",
-      "api",
-      "billing",
-      "cli"
-    ]);
+    init_universal_inference();
   }
 });
 
@@ -12132,8 +13050,8 @@ var init_co_change_analyzer = __esm({
 });
 
 // src/core/agents/lifecycle.ts
-import { existsSync as existsSync33, readdirSync as readdirSync11, statSync as statSync6 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync34, readdirSync as readdirSync12, statSync as statSync6 } from "fs";
+import { join as join35 } from "path";
 function analyzeLifecycle(projectPath, features, config2 = DEFAULT_LIFECYCLE_CONFIG, executor = new RealGitExecutor()) {
   const startTime = Date.now();
   const proposals = [];
@@ -12179,14 +13097,14 @@ function analyzeLifecycle(projectPath, features, config2 = DEFAULT_LIFECYCLE_CON
     }
   }
   const paths = getAgentWorkspacePaths(projectPath);
-  if (existsSync33(paths.featuresDir)) {
+  if (existsSync34(paths.featuresDir)) {
     try {
-      const featureDirs = readdirSync11(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const featureDirs = readdirSync12(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       const activeFeatureNames = new Set(features.map((f) => f.name));
       const cutoffDate = Date.now() - config2.pruneInactiveDays * 24 * 60 * 60 * 1e3;
       for (const dirName of featureDirs) {
         if (!activeFeatureNames.has(dirName)) {
-          const dirPath = join34(paths.featuresDir, dirName);
+          const dirPath = join35(paths.featuresDir, dirName);
           const stat = statSync6(dirPath);
           if (stat.mtimeMs < cutoffDate) {
             proposals.push({
@@ -12234,8 +13152,8 @@ var init_lifecycle = __esm({
 });
 
 // src/core/agents/orchestrator.ts
-import { existsSync as existsSync34, readFileSync as readFileSync27, readdirSync as readdirSync12 } from "fs";
-import { join as join35, relative as relative9 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync28, readdirSync as readdirSync13 } from "fs";
+import { join as join36, relative as relative9 } from "path";
 function agentsInit(projectPath) {
   const paths = initAgentWorkspace(projectPath);
   return {
@@ -12311,7 +13229,7 @@ async function agentsGenerate(options) {
     currentIndex.reResearchQueue = [];
     writeAgentIndex(projectPath, currentIndex);
   }
-  const intel = intelligence || createMinimalIntelligence(projectPath, technologies, features);
+  const intel = intelligence || createMinimalIntelligence(projectPath, technologies, features, importGraph);
   const genInput = {
     projectPath,
     intelligence: intel,
@@ -12421,8 +13339,8 @@ function agentsStatus(projectPath) {
   const paths = getAgentWorkspacePaths(projectPath);
   let researchFiles = 0;
   let staleResearch = 0;
-  if (existsSync34(paths.researchDir)) {
-    const files = readdirSync12(paths.researchDir);
+  if (existsSync35(paths.researchDir)) {
+    const files = readdirSync13(paths.researchDir);
     researchFiles = files.filter((f) => f.endsWith(".md")).length;
     const now = Date.now();
     for (const [tech, timestamp] of Object.entries(index.lastResearch)) {
@@ -12455,10 +13373,10 @@ function getIndexedFilesFromFS(projectPath) {
   function walk(dir, depth) {
     if (depth > 5) return;
     try {
-      const entries = readdirSync12(dir, { withFileTypes: true });
+      const entries = readdirSync13(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
-        const fullPath = join35(dir, entry.name);
+        const fullPath = join36(dir, entry.name);
         if (entry.isDirectory()) {
           walk(fullPath, depth + 1);
         } else {
@@ -12492,7 +13410,7 @@ function filterTopTechnologies(technologies) {
   ];
   return technologies.filter((t) => !skipPatterns.some((p) => p.test(t.name))).filter((t) => t.source.includes("lock") || t.source === "package.json").slice(0, 20);
 }
-function createMinimalIntelligence(projectPath, technologies, features) {
+function createMinimalIntelligence(projectPath, technologies, features, importGraph) {
   const sourceFiles = getIndexedFilesFromFS(projectPath);
   const codeFiles = sourceFiles.filter(
     (f) => /\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|cs|cpp|c|h)$/.test(f) && !f.includes("node_modules") && !f.includes("dist")
@@ -12500,7 +13418,7 @@ function createMinimalIntelligence(projectPath, technologies, features) {
   let totalLines = 0;
   for (const f of codeFiles.slice(0, 500)) {
     try {
-      const content = readFileSync27(join35(projectPath, f), "utf-8");
+      const content = readFileSync28(join36(projectPath, f), "utf-8");
       totalLines += content.split("\n").length;
     } catch {
     }
@@ -12515,7 +13433,7 @@ function createMinimalIntelligence(projectPath, technologies, features) {
   const layers = features.map((f) => ({
     name: f.name.charAt(0).toUpperCase() + f.name.slice(1),
     directory: f.paths[0]?.replace("/**", "") || f.name,
-    purpose: inferLayerPurpose(f.name),
+    purpose: inferDirectoryPurpose(f.name),
     fileCount: f.fileCount
   }));
   const testFramework = detectTestFramework(projectPath);
@@ -12532,7 +13450,7 @@ function createMinimalIntelligence(projectPath, technologies, features) {
     },
     architecture: {
       layers,
-      dataFlow: inferDataFlow(features),
+      dataFlow: inferDataFlowFromGraph(features, importGraph),
       keyComponents: [],
       patternCategories: {},
       topPatterns: [],
@@ -12563,7 +13481,7 @@ function buildFileTechMap(projectPath, indexedFiles, technologies) {
   );
   for (const file2 of sourceFiles.slice(0, 300)) {
     try {
-      const content = readFileSync27(join35(projectPath, file2), "utf-8");
+      const content = readFileSync28(join36(projectPath, file2), "utf-8");
       const techs = /* @__PURE__ */ new Set();
       const importRegex = /(?:from\s+['"]|require\s*\(\s*['"])([^./'"@][^'"]*|@[^/'"]+\/[^'"]+)/g;
       let match;
@@ -12601,39 +13519,11 @@ function extToLanguage(ext) {
   };
   return map2[ext] || null;
 }
-function inferLayerPurpose(featureName) {
-  const purposes = {
-    core: "Core business logic and domain modules",
-    server: "MCP server, transports, and request handling",
-    storage: "Database access and persistence layer",
-    indexing: "Code indexing, parsing, and symbol extraction",
-    api: "API routes, handlers, and middleware",
-    auth: "Authentication and authorization",
-    billing: "Payment processing and subscription management",
-    test: "Test fixtures, harness, and evaluation scenarios",
-    doc: "Documentation generation and management",
-    knowledge: "AI knowledge system and skill management",
-    cli: "Command-line interface",
-    base: "Base configuration and shared utilities"
-  };
-  return purposes[featureName] || `${featureName} module`;
-}
-function inferDataFlow(features) {
-  const names = features.map((f) => f.name);
-  const flow = [];
-  if (names.includes("server") || names.includes("api")) flow.push("Request");
-  if (names.includes("server")) flow.push("Server");
-  if (names.includes("api")) flow.push("API");
-  if (names.includes("core")) flow.push("Core");
-  if (names.includes("storage")) flow.push("Storage");
-  if (names.includes("indexing")) flow.push("Indexer");
-  return flow.length >= 2 ? flow : [];
-}
 function detectTestFramework(projectPath) {
-  const pkgPath = join35(projectPath, "package.json");
-  if (existsSync34(pkgPath)) {
+  const pkgPath = join36(projectPath, "package.json");
+  if (existsSync35(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync27(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync28(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (allDeps["vitest"]) return "vitest";
       if (allDeps["jest"]) return "jest";
@@ -12654,6 +13544,7 @@ var init_orchestrator = __esm({
     init_research_engine();
     init_generator();
     init_agent_generator();
+    init_universal_inference();
     init_git_operations();
     init_improvement_engine();
     init_outcome_storage();
@@ -12663,8 +13554,8 @@ var init_orchestrator = __esm({
 });
 
 // src/core/agents/migration.ts
-import { existsSync as existsSync35, readFileSync as readFileSync28, writeFileSync as writeFileSync20, mkdirSync as mkdirSync18, cpSync, readdirSync as readdirSync13 } from "fs";
-import { join as join36, relative as relative10, dirname as dirname15 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync29, writeFileSync as writeFileSync20, mkdirSync as mkdirSync18, cpSync, readdirSync as readdirSync14 } from "fs";
+import { join as join37, relative as relative10, dirname as dirname15 } from "path";
 function migrateKnowledge(options) {
   const { projectPath, dryRun = false, backup = false } = options;
   const result = {
@@ -12673,8 +13564,8 @@ function migrateKnowledge(options) {
     skipped: [],
     conflicts: []
   };
-  const knowledgeDir = join36(projectPath, "knowledge");
-  if (!existsSync35(knowledgeDir)) {
+  const knowledgeDir = join37(projectPath, "knowledge");
+  if (!existsSync36(knowledgeDir)) {
     result.skipped.push({ source: "knowledge/", reason: "Directory does not exist" });
     return result;
   }
@@ -12683,7 +13574,7 @@ function migrateKnowledge(options) {
   }
   const paths = getAgentWorkspacePaths(projectPath);
   if (backup && !dryRun) {
-    const backupDir = join36(projectPath, `knowledge-backup-${Date.now()}`);
+    const backupDir = join37(projectPath, `knowledge-backup-${Date.now()}`);
     cpSync(knowledgeDir, backupDir, { recursive: true });
     result.backupDir = backupDir;
   }
@@ -12696,7 +13587,7 @@ function migrateKnowledge(options) {
       continue;
     }
     const targetPath = resolveTargetPath(paths, classification);
-    if (existsSync35(targetPath) && !dryRun) {
+    if (existsSync36(targetPath) && !dryRun) {
       const merged = mergeSkills(skillFile, targetPath);
       if (merged) {
         result.conflicts.push({ source: relPath, target: relative10(projectPath, targetPath), resolution: "merged" });
@@ -12720,10 +13611,10 @@ function migrateKnowledge(options) {
 function discoverSkillFiles(dir) {
   const files = [];
   function walk(current) {
-    if (!existsSync35(current)) return;
-    const entries = readdirSync13(current, { withFileTypes: true });
+    if (!existsSync36(current)) return;
+    const entries = readdirSync14(current, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join36(current, entry.name);
+      const fullPath = join37(current, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.name === "SKILL.md" || entry.name.endsWith(".skill.md")) {
@@ -12760,19 +13651,19 @@ function classifySkillPath(relPath) {
 function resolveTargetPath(paths, classification) {
   switch (classification.type) {
     case "technology":
-      return join36(paths.projectDir, `${classification.name}-SKILL.md`);
+      return join37(paths.projectDir, `${classification.name}-SKILL.md`);
     case "feature":
-      return join36(paths.featuresDir, classification.name, "SKILL.md");
+      return join37(paths.featuresDir, classification.name, "SKILL.md");
     case "project":
-      return join36(paths.projectDir, "SKILL.md");
+      return join37(paths.projectDir, "SKILL.md");
     default:
-      return join36(paths.projectDir, `${classification.name}-SKILL.md`);
+      return join37(paths.projectDir, `${classification.name}-SKILL.md`);
   }
 }
 function mergeSkills(sourcePath, targetPath) {
   try {
-    const sourceContent = readFileSync28(sourcePath, "utf-8");
-    const targetContent = readFileSync28(targetPath, "utf-8");
+    const sourceContent = readFileSync29(sourcePath, "utf-8");
+    const targetContent = readFileSync29(targetPath, "utf-8");
     const sourceRules = extractSection2(sourceContent, "Rules");
     const sourcePitfalls = extractSection2(sourceContent, "Pitfalls");
     if (!sourceRules && !sourcePitfalls) return false;
@@ -12835,9 +13726,16 @@ __export(agents_exports, {
   DEFAULT_OUTPUT_DIR: () => DEFAULT_OUTPUT_DIR,
   DEFAULT_TRUST_CONFIG: () => DEFAULT_TRUST_CONFIG,
   DIAGNOSIS_RULES: () => DIAGNOSIS_RULES,
+  DIR_PURPOSE_MAP: () => DIR_PURPOSE_MAP,
+  DOC_SOURCE_REGISTRY: () => DOC_SOURCE_REGISTRY,
+  FEATURE_NAME_PITFALLS: () => FEATURE_NAME_PITFALLS,
+  FEATURE_NAME_RULES: () => FEATURE_NAME_RULES,
   MockGitExecutor: () => MockGitExecutor,
   RealGitExecutor: () => RealGitExecutor,
+  SCOPE_LABELS: () => SCOPE_LABELS,
   SECTION_PRIORITIES: () => SECTION_PRIORITIES,
+  TECH_KNOWLEDGE: () => TECH_KNOWLEDGE,
+  WELL_KNOWN_FEATURES: () => WELL_KNOWN_FEATURES,
   agentWorkspaceExists: () => agentWorkspaceExists,
   agentsGenerate: () => agentsGenerate,
   agentsInit: () => agentsInit,
@@ -12845,6 +13743,8 @@ __export(agents_exports, {
   analyzeCoChanges: () => analyzeCoChanges,
   analyzeLifecycle: () => analyzeLifecycle,
   assessTrust: () => assessTrust,
+  classifyFeature: () => classifyFeature,
+  classifyTechnology: () => classifyTechnology,
   commitAndPush: () => commitAndPush,
   commitChanges: () => commitChanges,
   computeContentHash: () => computeContentHash,
@@ -12856,6 +13756,8 @@ __export(agents_exports, {
   createOutcomeTable: () => createOutcomeTable,
   createTelemetryTable: () => createTelemetryTable,
   decayOldLessons: () => decayOldLessons,
+  deriveFeaturePitfalls: () => deriveFeaturePitfalls,
+  deriveFeatureRules: () => deriveFeatureRules,
   detectFeatures: () => detectFeatures,
   detectMonorepo: () => detectMonorepo,
   detectProvider: () => detectProvider,
@@ -12868,6 +13770,7 @@ __export(agents_exports, {
   ensureFeatureDir: () => ensureFeatureDir,
   estimateTokens: () => estimateTokens6,
   extractManualContent: () => extractManualContent,
+  extractRulesFromResearch: () => extractRulesFromResearch,
   findMergeCandidates: () => findMergeCandidates,
   generateAgentFiles: () => generateAgentFiles,
   generateAgentsShim: () => generateAgentsShim,
@@ -12884,6 +13787,11 @@ __export(agents_exports, {
   getResearchContent: () => getResearchContent,
   getSectionPriority: () => getSectionPriority,
   hasChanges: () => hasChanges,
+  inferDataFlowFromGraph: () => inferDataFlowFromGraph,
+  inferDirectoryPurpose: () => inferDirectoryPurpose,
+  inferDocSource: () => inferDocSource,
+  inferScopeLabel: () => inferScopeLabel,
+  inferTechRulesAndPitfalls: () => inferTechRulesAndPitfalls,
   initAgentWorkspace: () => initAgentWorkspace,
   isGitRepo: () => isGitRepo,
   learnFromOutcome: () => learnFromOutcome,
@@ -12929,6 +13837,8 @@ var init_agents = __esm({
     init_co_change_analyzer();
     init_lifecycle();
     init_telemetry();
+    init_hardcoded_knowledge();
+    init_universal_inference();
   }
 });
 
@@ -31291,8 +32201,8 @@ ${decision.files.map((f) => `- \`${f}\``).join("\n")}
   getExistingADRFiles(dir) {
     if (!existsSync6(dir)) return [];
     try {
-      const { readdirSync: readdirSync14 } = __require("fs");
-      return readdirSync14(dir).filter((f) => /^\d{4}-.*\.md$/.test(f)).sort();
+      const { readdirSync: readdirSync15 } = __require("fs");
+      return readdirSync15(dir).filter((f) => /^\d{4}-.*\.md$/.test(f)).sort();
     } catch {
       return [];
     }
@@ -43758,12 +44668,12 @@ var SkillEvolutionEngine = class {
     }
   }
   findSkillFile(dir, skillId) {
-    const { readdirSync: readdirSync14, statSync: statSync8 } = __require("fs");
-    const { join: join38 } = __require("path");
+    const { readdirSync: readdirSync15, statSync: statSync8 } = __require("fs");
+    const { join: join39 } = __require("path");
     if (!existsSync20(dir)) return null;
-    const entries = readdirSync14(dir);
+    const entries = readdirSync15(dir);
     for (const entry of entries) {
-      const fullPath = join38(dir, entry);
+      const fullPath = join39(dir, entry);
       const stat = statSync8(fullPath);
       if (stat.isDirectory()) {
         const found = this.findSkillFile(fullPath, skillId);
@@ -49200,8 +50110,8 @@ init_research_engine();
 init_outcome_storage();
 init_improvement_engine();
 init_telemetry();
-import { existsSync as existsSync27, readFileSync as readFileSync22, readdirSync as readdirSync9, writeFileSync as writeFileSync17 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync23, readdirSync as readdirSync10, writeFileSync as writeFileSync17 } from "fs";
+import { join as join28 } from "path";
 async function handleMemoryAgents(engine, input) {
   const projectPath = engine.getProjectPath();
   if (!agentWorkspaceExists(projectPath)) {
@@ -49242,34 +50152,34 @@ function handleListSkills(projectPath, input) {
   if (!input.scope || input.scope === "project") {
     const projectFiles = ["SKILL.md", "CONVENTIONS.md", "ARCHITECTURE.md"];
     for (const file2 of projectFiles) {
-      const filePath = join27(paths.projectDir, file2);
-      if (existsSync27(filePath)) {
+      const filePath = join28(paths.projectDir, file2);
+      if (existsSync28(filePath)) {
         skills.push({ name: file2.replace(".md", "").toLowerCase(), type: "project", path: `project/${file2}`, source: ".code-impact" });
       }
     }
   }
   if (!input.scope || input.scope === "feature") {
-    if (existsSync27(paths.featuresDir)) {
-      const features = readdirSync9(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    if (existsSync28(paths.featuresDir)) {
+      const features = readdirSync10(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       for (const feature of features) {
         if (input.feature && feature !== input.feature) continue;
-        const skillPath = join27(paths.featuresDir, feature, "SKILL.md");
-        if (existsSync27(skillPath)) {
+        const skillPath = join28(paths.featuresDir, feature, "SKILL.md");
+        if (existsSync28(skillPath)) {
           skills.push({ name: `${feature}-skill`, type: "feature", path: `features/${feature}/SKILL.md`, source: ".code-impact" });
         }
       }
     }
   }
-  const legacySkillsDir = join27(projectPath, "knowledge", "skills");
-  if (existsSync27(legacySkillsDir)) {
+  const legacySkillsDir = join28(projectPath, "knowledge", "skills");
+  if (existsSync28(legacySkillsDir)) {
     try {
       for (const scope of ["technology", "feature", "core", "risk"]) {
-        const scopeDir = join27(legacySkillsDir, scope);
-        if (!existsSync27(scopeDir)) continue;
-        const skillDirs = readdirSync9(scopeDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        const scopeDir = join28(legacySkillsDir, scope);
+        if (!existsSync28(scopeDir)) continue;
+        const skillDirs = readdirSync10(scopeDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
         for (const skillName of skillDirs) {
-          const skillPath = join27(scopeDir, skillName, "SKILL.md");
-          if (existsSync27(skillPath)) {
+          const skillPath = join28(scopeDir, skillName, "SKILL.md");
+          if (existsSync28(skillPath)) {
             const alreadyListed = skills.some((s) => s.name === skillName || s.name === `${skillName}-skill`);
             if (!alreadyListed) {
               skills.push({
@@ -49295,9 +50205,9 @@ function handleListSkills(projectPath, input) {
 function handleListAgents(projectPath) {
   const paths = getAgentWorkspacePaths(projectPath);
   const agents = [];
-  const superAgentPath = join27(paths.projectDir, "AGENT.md");
-  if (existsSync27(superAgentPath)) {
-    const content = readFileSync22(superAgentPath, "utf-8");
+  const superAgentPath = join28(paths.projectDir, "AGENT.md");
+  if (existsSync28(superAgentPath)) {
+    const content = readFileSync23(superAgentPath, "utf-8");
     const agent = parseAgentMd(content);
     if (agent) {
       agents.push({
@@ -49308,12 +50218,12 @@ function handleListAgents(projectPath) {
       });
     }
   }
-  if (existsSync27(paths.featuresDir)) {
-    const features = readdirSync9(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (existsSync28(paths.featuresDir)) {
+    const features = readdirSync10(paths.featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     for (const feature of features) {
-      const agentPath = join27(paths.featuresDir, feature, "AGENT.md");
-      if (existsSync27(agentPath)) {
-        const content = readFileSync22(agentPath, "utf-8");
+      const agentPath = join28(paths.featuresDir, feature, "AGENT.md");
+      if (existsSync28(agentPath)) {
+        const content = readFileSync23(agentPath, "utf-8");
         const agent = parseAgentMd(content);
         if (agent) {
           agents.push({
@@ -49338,32 +50248,32 @@ function handleGetSkill(projectPath, input) {
     return { success: false, action: "get_skill", message: "Missing required parameter: name" };
   }
   const paths = getAgentWorkspacePaths(projectPath);
-  const projectFile = join27(paths.projectDir, `${input.name.toUpperCase()}.md`);
-  if (existsSync27(projectFile)) {
+  const projectFile = join28(paths.projectDir, `${input.name.toUpperCase()}.md`);
+  if (existsSync28(projectFile)) {
     return {
       success: true,
       action: "get_skill",
       message: `Found project skill: ${input.name}`,
-      data: { content: readFileSync22(projectFile, "utf-8"), path: `project/${input.name.toUpperCase()}.md` }
+      data: { content: readFileSync23(projectFile, "utf-8"), path: `project/${input.name.toUpperCase()}.md` }
     };
   }
-  const skillFile = join27(paths.projectDir, "SKILL.md");
-  if (input.name === "project-overview" && existsSync27(skillFile)) {
+  const skillFile = join28(paths.projectDir, "SKILL.md");
+  if (input.name === "project-overview" && existsSync28(skillFile)) {
     return {
       success: true,
       action: "get_skill",
       message: "Found project skill",
-      data: { content: readFileSync22(skillFile, "utf-8"), path: "project/SKILL.md" }
+      data: { content: readFileSync23(skillFile, "utf-8"), path: "project/SKILL.md" }
     };
   }
   const featureName = input.name.replace(/-skill$/, "").replace(/-feature$/, "");
-  const featureSkill = join27(paths.featuresDir, featureName, "SKILL.md");
-  if (existsSync27(featureSkill)) {
+  const featureSkill = join28(paths.featuresDir, featureName, "SKILL.md");
+  if (existsSync28(featureSkill)) {
     return {
       success: true,
       action: "get_skill",
       message: `Found feature skill: ${featureName}`,
-      data: { content: readFileSync22(featureSkill, "utf-8"), path: `features/${featureName}/SKILL.md` }
+      data: { content: readFileSync23(featureSkill, "utf-8"), path: `features/${featureName}/SKILL.md` }
     };
   }
   return { success: false, action: "get_skill", message: `Skill not found: ${input.name}` };
@@ -49374,9 +50284,9 @@ function handleGetAgent(projectPath, input) {
   }
   const paths = getAgentWorkspacePaths(projectPath);
   if (input.name === "project-coordinator") {
-    const superPath = join27(paths.projectDir, "AGENT.md");
-    if (existsSync27(superPath)) {
-      const content = readFileSync22(superPath, "utf-8");
+    const superPath = join28(paths.projectDir, "AGENT.md");
+    if (existsSync28(superPath)) {
+      const content = readFileSync23(superPath, "utf-8");
       const agent = parseAgentMd(content);
       return {
         success: true,
@@ -49387,9 +50297,9 @@ function handleGetAgent(projectPath, input) {
     }
   }
   const featureName = input.name.replace(/-agent$/, "");
-  const agentPath = join27(paths.featuresDir, featureName, "AGENT.md");
-  if (existsSync27(agentPath)) {
-    const content = readFileSync22(agentPath, "utf-8");
+  const agentPath = join28(paths.featuresDir, featureName, "AGENT.md");
+  if (existsSync28(agentPath)) {
+    const content = readFileSync23(agentPath, "utf-8");
     const agent = parseAgentMd(content);
     return {
       success: true,
@@ -49422,15 +50332,15 @@ function handleValidateAction(projectPath, input) {
   const paths = getAgentWorkspacePaths(projectPath);
   let agentDef = null;
   if (input.agent === "project-coordinator") {
-    const superPath = join27(paths.projectDir, "AGENT.md");
-    if (existsSync27(superPath)) {
-      agentDef = parseAgentMd(readFileSync22(superPath, "utf-8"));
+    const superPath = join28(paths.projectDir, "AGENT.md");
+    if (existsSync28(superPath)) {
+      agentDef = parseAgentMd(readFileSync23(superPath, "utf-8"));
     }
   } else {
     const featureName = input.agent.replace(/-agent$/, "");
-    const agentPath = join27(paths.featuresDir, featureName, "AGENT.md");
-    if (existsSync27(agentPath)) {
-      agentDef = parseAgentMd(readFileSync22(agentPath, "utf-8"));
+    const agentPath = join28(paths.featuresDir, featureName, "AGENT.md");
+    if (existsSync28(agentPath)) {
+      agentDef = parseAgentMd(readFileSync23(agentPath, "utf-8"));
     }
   }
   if (!agentDef) {
@@ -49531,11 +50441,11 @@ function handleProposeImprovement(projectPath, input) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const paths = getAgentWorkspacePaths(projectPath);
-  const proposalsPath = join27(paths.root, "proposals.json");
+  const proposalsPath = join28(paths.root, "proposals.json");
   let proposals = [];
-  if (existsSync27(proposalsPath)) {
+  if (existsSync28(proposalsPath)) {
     try {
-      proposals = JSON.parse(readFileSync22(proposalsPath, "utf-8"));
+      proposals = JSON.parse(readFileSync23(proposalsPath, "utf-8"));
     } catch {
     }
   }
@@ -53234,13 +54144,13 @@ var StreamableHTTPServerTransport = class {
 };
 
 // src/utils/config.ts
-import { join as join28, resolve as resolve2 } from "path";
+import { join as join29, resolve as resolve2 } from "path";
 function getDefaultConfig(projectPath) {
   const normalizedPath = resolve2(projectPath);
   return {
     projectPath: normalizedPath,
     // Store in project directory (standard practice like .git/, .vscode/)
-    dataDir: join28(normalizedPath, ".codeimpact"),
+    dataDir: join29(normalizedPath, ".codeimpact"),
     maxTokens: 6e3,
     embeddingModel: "Xenova/all-MiniLM-L6-v2",
     // Fallback model, faster and smaller
@@ -53594,9 +54504,9 @@ To connect clients, run in each project:`);
 };
 
 // src/cli/commands.ts
-import { join as join37, resolve as resolve3 } from "path";
+import { join as join38, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync as existsSync36, readFileSync as readFileSync29, writeFileSync as writeFileSync21, mkdirSync as mkdirSync19 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync30, writeFileSync as writeFileSync21, mkdirSync as mkdirSync19 } from "fs";
 import { homedir as homedir2 } from "os";
 var projectManager = new ProjectManager();
 function listProjects() {
@@ -53711,10 +54621,10 @@ function exportDecisions(projectPath, options = {}) {
       message: `Project not registered: ${targetPath}. Use "codeimpact projects add ${targetPath}" first.`
     };
   }
-  let dbPath = join37(projectInfo.dataDir, "codeimpact.db");
-  if (!existsSync36(dbPath)) {
-    const oldDbPath = join37(projectInfo.dataDir, "codeimpact.db");
-    if (existsSync36(oldDbPath)) {
+  let dbPath = join38(projectInfo.dataDir, "codeimpact.db");
+  if (!existsSync37(dbPath)) {
+    const oldDbPath = join38(projectInfo.dataDir, "codeimpact.db");
+    if (existsSync37(oldDbPath)) {
       dbPath = oldDbPath;
     } else {
       return {
@@ -53741,17 +54651,17 @@ function exportDecisions(projectPath, options = {}) {
   });
   return {
     success: true,
-    message: `Exported ${exportedFiles.length} ADR files to ${options.outputDir || join37(targetPath, "docs", "decisions")}`,
+    message: `Exported ${exportedFiles.length} ADR files to ${options.outputDir || join38(targetPath, "docs", "decisions")}`,
     data: exportedFiles
   };
 }
 function findDatabasePath(projectInfo) {
-  const centralizedPath = join37(projectInfo.dataDir, "codeimpact.db");
-  if (existsSync36(centralizedPath)) {
+  const centralizedPath = join38(projectInfo.dataDir, "codeimpact.db");
+  if (existsSync37(centralizedPath)) {
     return centralizedPath;
   }
-  const projectLocalPath = join37(projectInfo.path, ".codeimpact", "codeimpact.db");
-  if (existsSync36(projectLocalPath)) {
+  const projectLocalPath = join38(projectInfo.path, ".codeimpact", "codeimpact.db");
+  if (existsSync37(projectLocalPath)) {
     return projectLocalPath;
   }
   return null;
@@ -54313,8 +55223,8 @@ function showProject(projectId) {
 function configureMCPClient(clientName, configPath, serverName, projectPath) {
   let config2 = { mcpServers: {} };
   try {
-    if (existsSync36(configPath)) {
-      const content = readFileSync29(configPath, "utf-8");
+    if (existsSync37(configPath)) {
+      const content = readFileSync30(configPath, "utf-8");
       config2 = JSON.parse(content);
     } else {
       const sep = process.platform === "win32" ? "\\" : "/";
@@ -54350,8 +55260,8 @@ function configureMCPClient(clientName, configPath, serverName, projectPath) {
 function configureProjectMCP(configPath, projectPath) {
   let config2 = { mcpServers: {} };
   try {
-    if (existsSync36(configPath)) {
-      const content = readFileSync29(configPath, "utf-8");
+    if (existsSync37(configPath)) {
+      const content = readFileSync30(configPath, "utf-8");
       config2 = JSON.parse(content);
     }
   } catch {
@@ -54383,7 +55293,7 @@ function configureProjectMCP(configPath, projectPath) {
   }
 }
 function configureClaudeMD(projectPath) {
-  const claudeMdPath = join37(projectPath, "CLAUDE.md");
+  const claudeMdPath = join38(projectPath, "CLAUDE.md");
   const codeimpactSection = `
 ## CodeImpact Integration
 
@@ -54453,8 +55363,8 @@ codeimpact reindex
 `;
   try {
     let existingContent = "";
-    if (existsSync36(claudeMdPath)) {
-      existingContent = readFileSync29(claudeMdPath, "utf-8");
+    if (existsSync37(claudeMdPath)) {
+      existingContent = readFileSync30(claudeMdPath, "utf-8");
       if (existingContent.includes("## CodeImpact Integration")) {
         const startMarker = "## CodeImpact Integration";
         const startIndex = existingContent.indexOf(startMarker);
@@ -54485,18 +55395,18 @@ ${codeimpactSection}`;
   }
 }
 function configureCursorProjectMCP(projectPath) {
-  const cursorDir = join37(projectPath, ".cursor");
-  const configPath = join37(cursorDir, "mcp.json");
+  const cursorDir = join38(projectPath, ".cursor");
+  const configPath = join38(cursorDir, "mcp.json");
   try {
-    if (!existsSync36(cursorDir)) {
+    if (!existsSync37(cursorDir)) {
       mkdirSync19(cursorDir, { recursive: true });
     }
   } catch {
   }
   let config2 = { mcpServers: {} };
   try {
-    if (existsSync36(configPath)) {
-      const content = readFileSync29(configPath, "utf-8");
+    if (existsSync37(configPath)) {
+      const content = readFileSync30(configPath, "utf-8");
       config2 = JSON.parse(content);
     }
   } catch {
@@ -54527,7 +55437,7 @@ function configureCursorProjectMCP(projectPath) {
   }
 }
 function configureCursorRules(projectPath) {
-  const cursorRulesPath = join37(projectPath, ".cursorrules");
+  const cursorRulesPath = join38(projectPath, ".cursorrules");
   const codeimpactSection = `
 # CodeImpact Integration
 
@@ -54591,8 +55501,8 @@ codeimpact stats
 `;
   try {
     let existingContent = "";
-    if (existsSync36(cursorRulesPath)) {
-      existingContent = readFileSync29(cursorRulesPath, "utf-8");
+    if (existsSync37(cursorRulesPath)) {
+      existingContent = readFileSync30(cursorRulesPath, "utf-8");
       if (existingContent.includes("# CodeImpact Integration")) {
         const startMarker = "# CodeImpact Integration";
         const startIndex = existingContent.indexOf(startMarker);
@@ -54621,11 +55531,11 @@ codeimpact stats
   }
 }
 function configureOpenCode(projectPath) {
-  const configPath = join37(projectPath, "opencode.json");
+  const configPath = join38(projectPath, "opencode.json");
   let config2 = {};
   try {
-    if (existsSync36(configPath)) {
-      const content = readFileSync29(configPath, "utf-8");
+    if (existsSync37(configPath)) {
+      const content = readFileSync30(configPath, "utf-8");
       config2 = JSON.parse(content);
     }
   } catch {
@@ -54661,8 +55571,8 @@ function configureOpenCode(projectPath) {
 function configureRemoteMCPClient(clientName, configPath, serverName, serverUrl) {
   let config2 = { mcpServers: {} };
   try {
-    if (existsSync36(configPath)) {
-      config2 = JSON.parse(readFileSync29(configPath, "utf-8"));
+    if (existsSync37(configPath)) {
+      config2 = JSON.parse(readFileSync30(configPath, "utf-8"));
     }
   } catch {
   }
@@ -54670,7 +55580,7 @@ function configureRemoteMCPClient(clientName, configPath, serverName, serverUrl)
   config2.mcpServers[serverName] = { url: serverUrl };
   try {
     const dir = configPath.substring(0, configPath.lastIndexOf("/") || configPath.lastIndexOf("\\"));
-    if (dir && !existsSync36(dir)) mkdirSync19(dir, { recursive: true });
+    if (dir && !existsSync37(dir)) mkdirSync19(dir, { recursive: true });
     writeFileSync21(configPath, JSON.stringify(config2, null, 2));
     return { success: true, message: `${clientName}: ${configPath}` };
   } catch (err) {
@@ -54690,27 +55600,27 @@ function initProject(projectPath, serverUrl) {
   const failedClients = [];
   let claudeConfigPath;
   if (platform === "win32") {
-    claudeConfigPath = join37(homedir2(), "AppData", "Roaming", "Claude", "claude_desktop_config.json");
+    claudeConfigPath = join38(homedir2(), "AppData", "Roaming", "Claude", "claude_desktop_config.json");
   } else if (platform === "darwin") {
-    claudeConfigPath = join37(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    claudeConfigPath = join38(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   } else {
-    claudeConfigPath = join37(homedir2(), ".config", "claude", "claude_desktop_config.json");
+    claudeConfigPath = join38(homedir2(), ".config", "claude", "claude_desktop_config.json");
   }
   if (serverUrl) {
     const remoteProjectUrl = `${serverUrl}/mcp?project=${encodeURIComponent(resolve3(targetPath))}`;
     const claudeResult = configureRemoteMCPClient("Claude Desktop", claudeConfigPath, serverName, remoteProjectUrl);
     if (claudeResult.success) configuredClients.push(claudeResult.message);
     else failedClients.push(claudeResult.message);
-    const claudeCodeConfigPath = join37(targetPath, ".mcp.json");
+    const claudeCodeConfigPath = join38(targetPath, ".mcp.json");
     const claudeCodeResult = configureRemoteMCPClient("Claude Code", claudeCodeConfigPath, "codeimpact", remoteProjectUrl);
     if (claudeCodeResult.success) configuredClients.push(claudeCodeResult.message);
     let cursorConfigPath;
     if (platform === "win32") {
-      cursorConfigPath = join37(homedir2(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
+      cursorConfigPath = join38(homedir2(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
     } else if (platform === "darwin") {
-      cursorConfigPath = join37(homedir2(), "Library", "Application Support", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
+      cursorConfigPath = join38(homedir2(), "Library", "Application Support", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
     } else {
-      cursorConfigPath = join37(homedir2(), ".config", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
+      cursorConfigPath = join38(homedir2(), ".config", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
     }
     const cursorResult = configureRemoteMCPClient("Cursor (global)", cursorConfigPath, serverName, remoteProjectUrl);
     if (cursorResult.success) configuredClients.push(cursorResult.message);
@@ -54722,16 +55632,16 @@ function initProject(projectPath, serverUrl) {
     const openCodeResult = configureOpenCode(targetPath);
     if (openCodeResult.success) configuredClients.push(openCodeResult.message);
     else failedClients.push(openCodeResult.message);
-    const claudeCodeConfigPath = join37(targetPath, ".mcp.json");
+    const claudeCodeConfigPath = join38(targetPath, ".mcp.json");
     const claudeCodeResult = configureProjectMCP(claudeCodeConfigPath, targetPath);
     if (claudeCodeResult.success) configuredClients.push(claudeCodeResult.message);
     let cursorConfigPath;
     if (platform === "win32") {
-      cursorConfigPath = join37(homedir2(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
+      cursorConfigPath = join38(homedir2(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
     } else if (platform === "darwin") {
-      cursorConfigPath = join37(homedir2(), "Library", "Application Support", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
+      cursorConfigPath = join38(homedir2(), "Library", "Application Support", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
     } else {
-      cursorConfigPath = join37(homedir2(), ".config", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
+      cursorConfigPath = join38(homedir2(), ".config", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json");
     }
     const cursorGlobalResult = configureMCPClient("Cursor (global)", cursorConfigPath, serverName, targetPath);
     if (cursorGlobalResult.success) configuredClients.push(cursorGlobalResult.message);