codeimpact 0.3.0 → 0.3.2

package/dist/index.js

@@ -8300,7 +8300,7 @@ function buildFeatureAgentDefinition(feature) {
       created_by: "code-impact"
     },
     scope: {
-      includedPaths: [...feature.paths, ...feature.testFiles],
+      includedPaths: [...feature.paths, ...deriveTestGlobs(feature)],
       excludedPaths: feature.paths.map((p) => p.replace("/**", "/__mocks__/**"))
     },
     allowedTools: [
@@ -8473,6 +8473,25 @@ function renderAgentsShim(agents, config2) {
   }
   return lines.join("\n");
 }
+function deriveTestGlobs(feature) {
+  if (feature.testFiles.length === 0) return [];
+  const dirCounts = /* @__PURE__ */ new Map();
+  for (const tf of feature.testFiles) {
+    const parts = tf.split("/");
+    const dir = parts.slice(0, -1).join("/");
+    dirCounts.set(dir, (dirCounts.get(dir) || 0) + 1);
+  }
+  const globs = [];
+  for (const [dir, count] of dirCounts) {
+    if (count >= 2) {
+      globs.push(`${dir}/**`);
+    } else {
+      const file2 = feature.testFiles.find((f) => f.startsWith(dir + "/"));
+      if (file2) globs.push(file2);
+    }
+  }
+  return globs;
+}
 function parseAgentMd(content) {
   try {
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
@@ -10464,7 +10483,9 @@ function findSubPackageJsons(projectPath) {
       const entries = readdirSync10(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") 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) {
@@ -10571,6 +10592,9 @@ function groupByDirectory(files, projectPath) {
     if (srcIdx >= 0 && parts.length > srcIdx + 2) {
       dirKey = parts.slice(0, srcIdx + 2).join("/");
     } else if (parts.length >= 2 && parts[0]) {
+      const topDir = parts[0].toLowerCase();
+      if (EXCLUDED_FEATURE_DIRS.has(topDir)) continue;
+      if (!SOURCE_TOP_DIRS.has(topDir)) continue;
       dirKey = parts[0];
     } else {
       continue;
@@ -10672,15 +10696,33 @@ function findTestFiles(featurePaths, allFiles) {
   return testFiles;
 }
 function isUtilityDir(dirName) {
-  return UTILITY_DIRS.has(dirName.toLowerCase());
+  const lower = dirName.toLowerCase();
+  return UTILITY_DIRS.has(lower) || EXCLUDED_FEATURE_DIRS.has(lower);
 }
 function slugify6(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
 }
-var UTILITY_DIRS;
+var SOURCE_TOP_DIRS, UTILITY_DIRS, EXCLUDED_FEATURE_DIRS;
 var init_feature_detector = __esm({
   "src/core/agents/feature-detector.ts"() {
     "use strict";
+    SOURCE_TOP_DIRS = /* @__PURE__ */ new Set([
+      "src",
+      "app",
+      "apps",
+      "packages",
+      "services",
+      "modules",
+      "test",
+      "tests",
+      "spec",
+      "e2e",
+      "api",
+      "lib",
+      "cmd",
+      "internal",
+      "pkg"
+    ]);
     UTILITY_DIRS = /* @__PURE__ */ new Set([
       "lib",
       "libs",
@@ -10699,6 +10741,47 @@ var init_feature_detector = __esm({
       "vendor",
       "third-party"
     ]);
+    EXCLUDED_FEATURE_DIRS = /* @__PURE__ */ new Set([
+      // Runtime-generated / workspace
+      "knowledge",
+      ".code-impact",
+      ".codeimpact",
+      ".claude",
+      ".cursor",
+      // Documentation
+      "doc",
+      "docs",
+      "documentation",
+      // Build / output
+      "dist",
+      "build",
+      "out",
+      ".next",
+      ".nuxt",
+      ".output",
+      // Dependencies
+      "node_modules",
+      ".yarn",
+      ".pnpm-store",
+      // CI / config
+      ".github",
+      ".gitlab",
+      ".circleci",
+      "scripts",
+      ".husky",
+      // Test fixtures (not features themselves)
+      "fixtures",
+      "base",
+      "__fixtures__",
+      "__snapshots__",
+      // Data / migrations
+      "migrations",
+      "seeds",
+      "data",
+      // IDE / editor
+      ".vscode",
+      ".idea"
+    ]);
   }
 });
 
@@ -11109,7 +11192,7 @@ var init_token_budget = __esm({
 });
 
 // src/core/agents/generator.ts
-import { mkdirSync as mkdirSync17 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync26, mkdirSync as mkdirSync17 } from "fs";
 import { join as join33 } from "path";
 function generateProjectFiles(input) {
   const { projectPath, intelligence, technologies, features, index } = input;
@@ -11118,7 +11201,7 @@ function generateProjectFiles(input) {
   const result = { filesWritten: [], filesSkipped: [] };
   mkdirSync17(paths.projectDir, { recursive: true });
   const skillPath = join33(paths.projectDir, "SKILL.md");
-  writeMarkedFile2(skillPath, renderProjectSkill(intelligence, technologies, config2), config2, result, "project_skill");
+  writeMarkedFile2(skillPath, renderProjectSkill(intelligence, technologies, config2, projectPath), config2, result, "project_skill");
   const convPath = join33(paths.projectDir, "CONVENTIONS.md");
   writeMarkedFile2(convPath, renderConventions(intelligence, config2), config2, result, "project_conventions");
   const archPath = join33(paths.projectDir, "ARCHITECTURE.md");
@@ -11139,7 +11222,7 @@ function generateFeatureFiles(input) {
   }
   return result;
 }
-function renderProjectSkill(intel, technologies, config2) {
+function renderProjectSkill(intel, technologies, config2, projectPath) {
   const frontmatter = [
     "---",
     "name: project-overview",
@@ -11156,9 +11239,13 @@ function renderProjectSkill(intel, technologies, config2) {
   const lines = [];
   lines.push("## Tech Stack");
   if (technologies.length > 0) {
-    const topTechs = technologies.slice(0, 15);
-    for (const tech of topTechs) {
-      lines.push(`- ${tech.name} ${tech.version} (from ${tech.source})`);
+    const directDeps = filterDirectDependencies(technologies, projectPath);
+    if (directDeps.length > 0) {
+      for (const tech of directDeps.slice(0, 20)) {
+        lines.push(`- ${tech.name} ${tech.version}`);
+      }
+    } else {
+      lines.push(`- Languages: ${intel.codebase.languages.join(", ")}`);
     }
   } else {
     lines.push(`- Languages: ${intel.codebase.languages.join(", ")}`);
@@ -11186,7 +11273,9 @@ function renderProjectSkill(intel, technologies, config2) {
     }
   } else {
     for (const dir of intel.codebase.keyDirectories) {
-      lines.push(`| ${dir}/ | Source code |`);
+      const dirName = dir.split("/").pop() || dir;
+      const purpose = inferDirPurpose(dirName);
+      lines.push(`| ${dir}/ | ${purpose} |`);
     }
   }
   lines.push("");
@@ -11309,8 +11398,9 @@ function renderFeatureSkill(feature, technologies, config2) {
     lines.push(`- ${p}`);
   }
   if (feature.testFiles.length > 0) {
-    for (const tf of feature.testFiles) {
-      lines.push(`- ${tf}`);
+    const testGlobs = summarizeTestFiles(feature.testFiles);
+    for (const tg of testGlobs) {
+      lines.push(`- ${tg}`);
     }
   }
   lines.push("");
@@ -11335,46 +11425,15 @@ function renderFeatureSkill(feature, technologies, config2) {
     lines.push("");
   }
   lines.push("## Rules");
-  if (technologies.length > 0) {
-    for (const tech of technologies) {
-      if (tech.name === "express") {
-        lines.push("- Use Router() for modular route definitions");
-        lines.push("- Always register error handler middleware last");
-      } else if (tech.name === "better-sqlite3") {
-        lines.push("- Use db.prepare().all() for SELECT, db.prepare().run() for INSERT/UPDATE/DELETE");
-        lines.push("- better-sqlite3 is synchronous \u2014 do NOT use async/await");
-      } else if (tech.name === "stripe") {
-        lines.push("- Always verify webhook signatures before processing events");
-        lines.push("- Use idempotency keys for payment creation");
-      } else if (tech.name === "jsonwebtoken") {
-        lines.push("- Always verify tokens before trusting decoded data");
-        lines.push("- Set explicit expiration times on all tokens");
-      } else {
-        lines.push(`- Follow ${tech.name} v${tech.version} API conventions`);
-      }
-    }
-  } else {
-    lines.push("- Follow project coding conventions for this feature");
+  const rules = deriveRules(feature, technologies);
+  for (const rule of rules) {
+    lines.push(`- ${rule}`);
   }
   lines.push("");
   lines.push("## Pitfalls");
-  if (technologies.length > 0) {
-    for (const tech of technologies) {
-      if (tech.name === "express") {
-        lines.push("- Forgetting to call next() in middleware causes request to hang");
-      } else if (tech.name === "better-sqlite3") {
-        lines.push("- db.exec() returns nothing \u2014 using it for SELECT gives undefined");
-      } else if (tech.name === "stripe") {
-        lines.push("- Stripe webhook events may arrive out of order \u2014 handle idempotently");
-      } else if (tech.name === "jsonwebtoken") {
-        lines.push("- Using jwt.decode() without verify() is a security vulnerability");
-      }
-    }
-    if (technologies.every((t) => !["express", "better-sqlite3", "stripe", "jsonwebtoken"].includes(t.name))) {
-      lines.push("- Check research docs for version-specific breaking changes");
-    }
-  } else {
-    lines.push("- Check for null/undefined before property access on external data");
+  const pitfalls = derivePitfalls(feature, technologies);
+  for (const pitfall of pitfalls) {
+    lines.push(`- ${pitfall}`);
   }
   lines.push("");
   return { frontmatter, autoContent: lines.join("\n") };
@@ -11424,15 +11483,348 @@ function parseAutoContentSections(autoContent) {
   }
   return sections;
 }
+function summarizeTestFiles(testFiles) {
+  if (testFiles.length === 0) return [];
+  const dirCounts = /* @__PURE__ */ new Map();
+  for (const tf of testFiles) {
+    const parts = tf.split("/");
+    const dir = parts.slice(0, -1).join("/");
+    dirCounts.set(dir, (dirCounts.get(dir) || 0) + 1);
+  }
+  const globs = [];
+  for (const [dir, count] of dirCounts) {
+    if (count >= 2) {
+      globs.push(`${dir}/**`);
+    } else {
+      const file2 = testFiles.find((f) => f.startsWith(dir + "/"));
+      if (file2) globs.push(file2);
+    }
+  }
+  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) {
   return str.charAt(0).toUpperCase() + str.slice(1).replace(/-/g, " ");
 }
+function filterDirectDependencies(technologies, projectPath) {
+  const directNames = /* @__PURE__ */ new Set();
+  for (const tech of technologies) {
+    if (tech.source === "package.json") {
+      directNames.add(tech.name);
+    }
+  }
+  if (directNames.size === 0) {
+    const searchPaths = [
+      projectPath ? join33(projectPath, "package.json") : "",
+      join33(process.cwd(), "package.json")
+    ].filter(Boolean);
+    for (const p of searchPaths) {
+      try {
+        if (existsSync32(p)) {
+          const pkg = JSON.parse(readFileSync26(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;
+        }
+      } catch {
+      }
+    }
+  }
+  const skipPatterns = [
+    /^@types\//,
+    /^@esbuild\//,
+    /^@rollup\//,
+    /^@swc\//,
+    /^@parcel\//,
+    /^@biomejs\//
+  ];
+  if (directNames.size > 0) {
+    return technologies.filter((t) => directNames.has(t.name)).filter((t) => !skipPatterns.some((p) => p.test(t.name)));
+  }
+  return technologies.filter((t) => !skipPatterns.some((p) => p.test(t.name))).slice(0, 20);
+}
+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"
+    ]);
   }
 });
 
@@ -11842,7 +12234,7 @@ var init_lifecycle = __esm({
 });
 
 // src/core/agents/orchestrator.ts
-import { existsSync as existsSync34, readdirSync as readdirSync12 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync27, readdirSync as readdirSync12 } from "fs";
 import { join as join35, relative as relative9 } from "path";
 function agentsInit(projectPath) {
   const paths = initAgentWorkspace(projectPath);
@@ -11877,11 +12269,13 @@ async function agentsGenerate(options) {
   result.technologies = technologies.length;
   const importGraph = options.importGraph || /* @__PURE__ */ new Map();
   const indexedFiles = options.indexedFiles || getIndexedFilesFromFS(projectPath);
+  const fileTechMap = buildFileTechMap(projectPath, indexedFiles, technologies);
   const featureInput = {
     projectPath,
     config: config2.feature_detection,
     importGraph,
-    indexedFiles
+    indexedFiles,
+    fileTechMap
   };
   const features = detectFeatures(featureInput);
   result.features = features.length;
@@ -12099,30 +12493,57 @@ 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) {
+  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")
+  );
+  let totalLines = 0;
+  for (const f of codeFiles.slice(0, 500)) {
+    try {
+      const content = readFileSync27(join35(projectPath, f), "utf-8");
+      totalLines += content.split("\n").length;
+    } catch {
+    }
+  }
+  const extCounts = /* @__PURE__ */ new Map();
+  for (const f of codeFiles) {
+    const ext = f.split(".").pop() || "";
+    const lang = extToLanguage(ext);
+    if (lang) extCounts.set(lang, (extCounts.get(lang) || 0) + 1);
+  }
+  const languages = [...extCounts.entries()].sort((a, b) => b[1] - a[1]).map(([lang]) => lang);
+  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),
+    fileCount: f.fileCount
+  }));
+  const testFramework = detectTestFramework(projectPath);
   return {
     collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
     codebase: {
-      fileCount: 0,
-      totalLines: 0,
-      languages: [...new Set(technologies.map((t) => {
-        if (t.source.includes("package")) return "typescript";
-        if (t.source.includes("Cargo")) return "rust";
-        if (t.source.includes("go.")) return "go";
-        if (t.source.includes("requirements") || t.source.includes("pyproject")) return "python";
-        return "unknown";
-      }))],
+      fileCount: codeFiles.length,
+      totalLines,
+      languages: languages.length > 0 ? languages : ["typescript"],
       keyDirectories: features.map((f) => f.paths[0]?.replace("/**", "") || ""),
       symbolCount: 0,
       description: "",
       architectureNotes: ""
     },
-    architecture: null,
+    architecture: {
+      layers,
+      dataFlow: inferDataFlow(features),
+      keyComponents: [],
+      patternCategories: {},
+      topPatterns: [],
+      functionStats: { total: 0, exported: 0 }
+    },
     dependencyHotspots: [],
     patterns: [],
     decisions: [],
     riskFiles: [],
     deadCode: null,
-    tests: { framework: "unknown", testCount: 0, coverageGaps: [], uncoveredFunctions: [] },
+    tests: { framework: testFramework, testCount: 0, coverageGaps: [], uncoveredFunctions: [] },
     recentBugs: [],
     changeHotspots: [],
     activeFeature: null,
@@ -12134,6 +12555,96 @@ function createMinimalIntelligence(projectPath, technologies, features) {
     }))
   };
 }
+function buildFileTechMap(projectPath, indexedFiles, technologies) {
+  const techNames = new Set(technologies.map((t) => t.name));
+  const fileTechMap = /* @__PURE__ */ new Map();
+  const sourceFiles = indexedFiles.filter(
+    (f) => /\.(ts|tsx|js|jsx)$/.test(f) && !f.includes("node_modules") && !f.includes("dist")
+  );
+  for (const file2 of sourceFiles.slice(0, 300)) {
+    try {
+      const content = readFileSync27(join35(projectPath, file2), "utf-8");
+      const techs = /* @__PURE__ */ new Set();
+      const importRegex = /(?:from\s+['"]|require\s*\(\s*['"])([^./'"@][^'"]*|@[^/'"]+\/[^'"]+)/g;
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        const pkg = match[1] || "";
+        const normalized = pkg.startsWith("@") ? pkg.split("/").slice(0, 2).join("/") : pkg.split("/")[0] || "";
+        if (normalized && techNames.has(normalized)) {
+          techs.add(normalized);
+        }
+      }
+      if (techs.size > 0) {
+        fileTechMap.set(file2, [...techs]);
+      }
+    } catch {
+    }
+  }
+  return fileTechMap;
+}
+function extToLanguage(ext) {
+  const map2 = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    py: "python",
+    go: "go",
+    rs: "rust",
+    java: "java",
+    rb: "ruby",
+    php: "php",
+    cs: "c#",
+    cpp: "c++",
+    c: "c",
+    h: "c"
+  };
+  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)) {
+    try {
+      const pkg = JSON.parse(readFileSync27(pkgPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps["vitest"]) return "vitest";
+      if (allDeps["jest"]) return "jest";
+      if (allDeps["mocha"]) return "mocha";
+      if (allDeps["tap"]) return "tap";
+      if (pkg.scripts?.test?.includes("--test")) return "node:test";
+    } catch {
+    }
+  }
+  return "unknown";
+}
 var init_orchestrator = __esm({
   "src/core/agents/orchestrator.ts"() {
     "use strict";
@@ -12153,7 +12664,7 @@ 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 dirname14 } from "path";
+import { join as join36, relative as relative10, dirname as dirname15 } from "path";
 function migrateKnowledge(options) {
   const { projectPath, dryRun = false, backup = false } = options;
   const result = {
@@ -12195,7 +12706,7 @@ function migrateKnowledge(options) {
       continue;
     }
     if (!dryRun) {
-      mkdirSync18(dirname14(targetPath), { recursive: true });
+      mkdirSync18(dirname15(targetPath), { recursive: true });
       cpSync(skillFile, targetPath);
     }
     result.migrated.push({
@@ -42751,22 +43262,32 @@ ${END_MARKER}`;
     return { content: `${block}
 `, changed: true };
   }
-  const start = existing.indexOf(START_MARKER);
-  const end = existing.indexOf(END_MARKER);
-  if (start >= 0 && end > start) {
-    const before = existing.slice(0, start).trimEnd();
-    const after = existing.slice(end + END_MARKER.length).trimStart();
-    const content2 = `${before}
-
-${block}
-
-${after}`.trim() + "\n";
-    return { content: content2, changed: content2 !== existing };
+  let cleaned = existing;
+  let hadMarkers = false;
+  while (true) {
+    const start = cleaned.indexOf(START_MARKER);
+    const end = cleaned.indexOf(END_MARKER, start >= 0 ? start : 0);
+    if (start >= 0 && end > start) {
+      hadMarkers = true;
+      cleaned = cleaned.slice(0, start) + cleaned.slice(end + END_MARKER.length);
+    } else if (end >= 0 && start < 0) {
+      hadMarkers = true;
+      cleaned = cleaned.slice(0, end) + cleaned.slice(end + END_MARKER.length);
+    } else {
+      break;
+    }
   }
-  const content = `${existing.trimEnd()}
+  cleaned = cleaned.replace(/\n{3,}/g, "\n\n").trim();
+  let content;
+  if (!cleaned) {
+    content = `${block}
+`;
+  } else {
+    content = `${cleaned}
 
 ${block}
 `;
+  }
   return { content, changed: content !== existing };
 }
 function writeManagedFile(targetPath, section, options) {
@@ -42799,93 +43320,61 @@ function renderPlatformSection(platform, paths, skillIndex, evolutionGuidance) {
   let attentionSection = "";
   if (evolutionGuidance && evolutionGuidance.length > 0) {
     attentionSection = `
-
 ### Skills Needing Attention
 ${evolutionGuidance.map((g) => `- ${g}`).join("\n")}`;
   }
-  return `# CodeImpact Knowledge System
+  return `# CodeImpact \u2014 AI-Powered Codebase Intelligence
+
+You have access to **CodeImpact**, a persistent knowledge system that understands this codebase. It provides project skills, architecture knowledge, and self-learning agents.
 
-You are part of a **self-improving knowledge system**. Skills you create persist across sessions. Future AI sessions benefit from the knowledge you build now.
+## IMPORTANT: Session Start
+
+1. **Read project knowledge** before making changes:
+   - \`.code-impact/project/SKILL.md\` \u2014 Tech stack, architecture, key directories
+   - \`.code-impact/project/CONVENTIONS.md\` \u2014 Coding standards and patterns
+   - \`.code-impact/project/ARCHITECTURE.md\` \u2014 System layers and data flow
+2. **Read feature knowledge** for the files you're modifying:
+   - \`.code-impact/features/{feature}/SKILL.md\` \u2014 Feature-specific rules, pitfalls, and research refs
+   - Features: check \`.code-impact/features/\` for available feature directories
+3. Run \`${tool("memory_status")}\` for project overview and recent changes
+
+## MCP Tools (Use FIRST before built-in tools)
 
-## Tools
 | Task | Tool |
 |------|------|
-| Find code | \`${tool("memory_query")}\` |
-| Check code | \`${tool("memory_review")}\` |
-| Verify code | \`${tool("memory_verify")}\` |
+| Search code semantically | \`${tool("memory_query")}\` |
+| Review code before changes | \`${tool("memory_review")}\` |
+| Verify before committing | \`${tool("memory_verify")}\` |
 | Project status | \`${tool("memory_status")}\` |
 | Impact analysis | \`${tool("memory_blast_radius")}\` |
+| Agent system | \`${tool("memory_agents")}\` |
 | Build knowledge | \`${tool("memory_evolve")}\` |
 
-## Session Start
-1. Run \`${tool("memory_status")}\` \u2014 check \`knowledge_gaps\` for uncovered technologies and high-risk files.
-2. Read relevant skills from \`knowledge/skills/\` for the current task.
-
-## Skill Creation Protocol
+## Agent System
 
-**After completing any task involving 3+ files**, create or improve a skill.
+This project has feature-level agents in \`.code-impact/features/\`. Each agent has:
+- **SKILL.md** \u2014 Rules, pitfalls, and technology-specific guidance
+- **AGENT.md** \u2014 Scope, allowed tools, and lessons learned from past mistakes
 
-### To create a new skill:
-\`${tool("memory_evolve")}\` with:
-- action="create_skill"
-- name="technology-or-area-name" (slug format)
-- description="One line: when to use this skill"
-- scope="technology|feature|risk|core"
-- content="Full markdown body (see format below)"
+Before modifying files, check the relevant feature's SKILL.md for rules and pitfalls.
+After completing a task, record the outcome via \`${tool("memory_agents")}\` with action="record_outcome".
 
-### To improve an existing skill:
-\`${tool("memory_evolve")}\` with:
-- action="improve_skill", skill_id="skill-name"
-- Patch mode: old_text="exact text to replace", new_text="replacement"
-- Append mode: section="pitfalls", content="New pitfall to add"
+## Skill Management
 
-### To discover gaps:
-\`${tool("memory_evolve")}\` with action="list_signals"
+After completing any task involving 3+ files, create or improve a skill:
 
-### Skill Format (agentskills.io SKILL.md)
-
-\`\`\`markdown
----
-name: better-sqlite3-patterns
-description: Synchronous database patterns. Use when working with database queries or schema changes.
-version: 1.0
-metadata:
-  scope: technology
-  created_by: ai
----
-
-# better-sqlite3 Patterns
-
-## When to Use
-When modifying database queries, adding tables, or working with files that import from src/storage/database.ts.
-
-## Key Facts
-- Database: .codeimpact/codeimpact.db (SQLite, WAL mode)
-- API: better-sqlite3 (synchronous, NOT async)
-
-## Rules
-- ALL database access goes through database.ts \u2014 never import better-sqlite3 directly.
-- Use db.prepare().all() for SELECT, db.prepare().run() for INSERT/UPDATE/DELETE.
-
-## Pitfalls
-- db.exec() returns nothing. If you use it for SELECT, you get undefined.
-- better-sqlite3 is synchronous. Do NOT wrap in async/await.
-
-## Verification
-- npx tsc --noEmit passes with no type errors on database code.
-\`\`\`
+\`${tool("memory_evolve")}\` with action="create_skill" (new) or action="improve_skill" (update)
 
 ### Quality Rules
-- **Under 5000 tokens** per skill
-- **Be specific**: "Use db.prepare().all() for SELECT" not "follow project patterns"
-- **Pitfalls with symptoms**: "you'll get undefined" not "don't misuse"
-- **Every line earns its tokens** \u2014 no filler, no generic advice the AI already knows
+- Under 5000 tokens per skill
+- Be specific: "Use db.prepare().all() for SELECT" not "follow project patterns"
+- Include pitfalls with symptoms: "you'll get undefined" not "don't misuse"
 
 ## Existing Skills
 ${skillList}
 ${attentionSection}
 
-## Workspace
+## Knowledge Workspace
 \`${paths.root.replace(/\\/g, "/")}\``;
 }
 var PlatformRuleSync = class {