project-librarian 0.5.4 → 0.5.6

package/dist/code-index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeEvidenceIndexUnavailableError = exports.codeContextPackTruncationNotice = exports.codeContextPackCharCap = exports.codeIndexSnapshot = exports.workspaceSummary = exports.workspaceDependencyGraph = exports.searchSymbols = exports.ownershipInfo = exports.ownershipContext = exports.matchedCodeownerRules = exports.evidenceCoverage = exports.codeownerRules = void 0;
+exports.CodeEvidenceIndexUnavailableError = exports.nativeCodeIndexAutoFileThreshold = exports.codeContextPackTruncationNotice = exports.codeContextPackCharCap = exports.codeIndexSnapshot = exports.workspaceSummary = exports.workspaceDependencyGraph = exports.searchSymbols = exports.ownershipInfo = exports.ownershipContext = exports.matchedCodeownerRules = exports.evidenceCoverage = exports.codeownerRules = void 0;
 exports.codeIndexStaleness = codeIndexStaleness;
 exports.codeIndexHealth = codeIndexHealth;
 exports.codeImpact = codeImpact;
@@ -61,6 +61,7 @@ const registry_1 = require("./code-index/extractors/registry");
 const shared_1 = require("./code-index/extractors/shared");
 const index_health_1 = require("./code-index/index-health");
 const modes_1 = require("./code-index/modes");
+const native_helper_1 = require("./code-index/native-helper");
 const ownership_1 = require("./code-index/ownership");
 Object.defineProperty(exports, "codeownerRules", { enumerable: true, get: function () { return ownership_1.codeownerRules; } });
 Object.defineProperty(exports, "matchedCodeownerRules", { enumerable: true, get: function () { return ownership_1.matchedCodeownerRules; } });
@@ -77,6 +78,8 @@ Object.defineProperty(exports, "searchSymbols", { enumerable: true, get: functio
 const workspace_1 = require("./workspace");
 exports.codeContextPackCharCap = 4000;
 exports.codeContextPackTruncationNotice = "[truncated - refine the query]";
+exports.nativeCodeIndexAutoFileThreshold = 1;
+const codeFileFingerprintPaths = new Map();
 function fail(message) {
     console.error(message);
     process.exit(1);
@@ -110,30 +113,82 @@ function selectedCodeParserMode() {
         return "tree-sitter";
     fail(`invalid --code-parser: ${args_1.codeParser}; expected one of: default, tree-sitter`);
 }
+function selectedCodeIndexEngine() {
+    const requested = args_1.codeIndexEngine.trim().toLowerCase();
+    if (!requested || requested === "auto")
+        return "auto";
+    if (requested === "typescript")
+        return "typescript";
+    if (requested === "native-rust")
+        return "native-rust";
+    fail(`invalid --code-index-engine: ${args_1.codeIndexEngine}; expected one of: auto, typescript, native-rust`);
+}
+function codeIndexEngineSelectionContext(discoveredFiles, parserMode) {
+    let nativeEligibleFileCount = 0;
+    for (const filePath of discoveredFiles) {
+        const language = (0, code_index_file_policy_1.fileLanguage)(filePath) || "config";
+        if (nativeAutoEligibleProfile((0, registry_1.extractionProfile)(filePath, language, parserMode)))
+            nativeEligibleFileCount += 1;
+    }
+    return {
+        discoveredFileCount: discoveredFiles.length,
+        nativeEligibleFileCount,
+        nativeIneligibleFileCount: discoveredFiles.length - nativeEligibleFileCount,
+    };
+}
+function shouldUseNativeCodeIndexAuto(context) {
+    return context.nativeEligibleFileCount >= exports.nativeCodeIndexAutoFileThreshold
+        && (0, native_helper_1.nativeCodeIndexHelperAvailable)();
+}
+function nativeCodeIndexAvailable() {
+    return (0, native_helper_1.nativeCodeIndexHelperAvailable)();
+}
 function normalizedMtimeMs(stat) {
     return Number(stat.mtimeMs.toFixed(3));
 }
 function readCodeFileFingerprint(relativePath) {
-    const stat = fs.statSync((0, workspace_1.abs)(relativePath));
+    const discovered = (0, code_index_file_policy_1.cachedDiscoveredCodeFileStat)(relativePath);
+    const { absolutePath, stat } = discovered ?? (0, workspace_1.requireContainedProjectFile)(relativePath, "code-index file");
+    codeFileFingerprintPaths.set(relativePath, absolutePath);
     return {
         mtimeMs: normalizedMtimeMs(stat),
         path: relativePath,
         size: stat.size,
     };
 }
-function readCodeFile(relativePath, parserMode = "default") {
-    const text = fs.readFileSync((0, workspace_1.abs)(relativePath), "utf8");
-    const fingerprint = readCodeFileFingerprint(relativePath);
+function lineCount(text) {
+    if (text.length === 0)
+        return 0;
+    let lines = 1;
+    for (let index = 0; index < text.length; index += 1) {
+        if (text.charCodeAt(index) === 10)
+            lines += 1;
+    }
+    return lines;
+}
+function readCodeFile(relativePath, parserMode = "default", fingerprint) {
+    let effectiveFingerprint = fingerprint;
+    let absolutePath = effectiveFingerprint ? codeFileFingerprintPaths.get(relativePath) : undefined;
+    if (!absolutePath || !effectiveFingerprint) {
+        const contained = (0, workspace_1.requireContainedProjectFile)(relativePath, "code-index file");
+        absolutePath = contained.absolutePath;
+        effectiveFingerprint ??= {
+            mtimeMs: normalizedMtimeMs(contained.stat),
+            path: relativePath,
+            size: contained.stat.size,
+        };
+    }
+    const text = fs.readFileSync(absolutePath, "utf8");
     const language = (0, code_index_file_policy_1.fileLanguage)(relativePath) || "config";
     return {
-        bytes: fingerprint.size,
+        bytes: effectiveFingerprint.size,
         hash: crypto.createHash("sha256").update(text).digest("hex"),
         language,
-        lines: text.length === 0 ? 0 : text.split(/\r?\n/).length,
-        mtimeMs: fingerprint.mtimeMs,
+        lines: lineCount(text),
+        mtimeMs: effectiveFingerprint.mtimeMs,
         path: relativePath,
         profile: (0, registry_1.extractionProfile)(relativePath, language, parserMode),
-        size: fingerprint.size,
+        size: effectiveFingerprint.size,
         text,
     };
 }
@@ -142,8 +197,9 @@ function extractionBackendForProfile(profile) {
     return extractionBackendRegistry.backendForProfile(profile);
 }
 function indexCodeFile(file, statements) {
-    statements.insertFile.run(file.path, file.language, file.profile, file.language === "config" ? "config" : "source", file.bytes, file.lines, file.hash, file.mtimeMs, file.size);
-    statements.insertFileFts.run(file.path, file.language, file.profile, file.text);
+    const ftsRowid = (0, schema_1.fileFtsRowid)(file.path);
+    statements.insertFile.run(file.path, ftsRowid, file.language, file.profile, file.language === "config" ? "config" : "source", file.bytes, file.lines, file.hash, file.mtimeMs, file.size);
+    statements.insertFileFts.run(ftsRowid, file.path, file.language, file.profile, file.text);
     extractionBackendForProfile(file.profile).index(file, statements);
 }
 function printRows(rows) {
@@ -172,6 +228,295 @@ function removeDatabaseFiles(databasePath) {
             fs.unlinkSync(filePath);
     }
 }
+function moveDatabaseFiles(sourcePath, targetPath) {
+    const backupPath = `${targetPath}.backup-${process.pid}-${Date.now()}`;
+    removeDatabaseFiles(backupPath);
+    for (const suffix of ["", "-wal", "-shm"]) {
+        const target = `${targetPath}${suffix}`;
+        if (fs.existsSync(target))
+            fs.renameSync(target, `${backupPath}${suffix}`);
+    }
+    try {
+        for (const suffix of ["", "-wal", "-shm"]) {
+            const source = `${sourcePath}${suffix}`;
+            if (fs.existsSync(source))
+                fs.renameSync(source, `${targetPath}${suffix}`);
+        }
+        removeDatabaseFiles(backupPath);
+    }
+    catch (error) {
+        removeDatabaseFiles(targetPath);
+        for (const suffix of ["", "-wal", "-shm"]) {
+            const backup = `${backupPath}${suffix}`;
+            if (fs.existsSync(backup))
+                fs.renameSync(backup, `${targetPath}${suffix}`);
+        }
+        throw error;
+    }
+}
+function removeTemporaryDatabaseFiles(databasePath) {
+    for (const suffix of ["", "-wal", "-shm"]) {
+        const filePath = `${databasePath}${suffix}`;
+        if (fs.existsSync(filePath))
+            fs.unlinkSync(filePath);
+    }
+}
+function nativeCodeIndexFileFor(filePath, parserMode) {
+    const fingerprint = readCodeFileFingerprint(filePath);
+    const language = (0, code_index_file_policy_1.fileLanguage)(filePath) || "config";
+    return {
+        ...fingerprint,
+        language,
+        profile: (0, registry_1.extractionProfile)(filePath, language, parserMode),
+    };
+}
+function nativeCodeIndexFileFromCodeFile(file) {
+    return {
+        language: file.language,
+        mtimeMs: file.mtimeMs,
+        path: file.path,
+        profile: file.profile,
+        size: file.size,
+    };
+}
+function nativeCodeIndexFileFromFingerprint(file, parserMode) {
+    const language = (0, code_index_file_policy_1.fileLanguage)(file.path) || "config";
+    return {
+        language,
+        mtimeMs: file.mtimeMs,
+        path: file.path,
+        profile: (0, registry_1.extractionProfile)(file.path, language, parserMode),
+        size: file.size,
+    };
+}
+function nativeEligibleProfile(profile) {
+    return nativeAutoEligibleProfile(profile) || profile === "config" || profile === "inventory-only";
+}
+function nativeCodeIndexIncrementalEligible(files, parserMode) {
+    return files.every((file) => nativeEligibleProfile(nativeCodeIndexFileFromFingerprint(file, parserMode).profile));
+}
+function nativeAutoEligibleProfile(profile) {
+    return [
+        "typescript-ast",
+        "python-light",
+        "go-light",
+        "c-light",
+        "cpp-light",
+        "csharp-light",
+        "java-light",
+        "kotlin-light",
+        "php-light",
+        "rust-light",
+        "swift-light",
+    ].includes(profile);
+}
+function nativeCodeIndexOutputMode() {
+    const requested = (process.env.PROJECT_LIBRARIAN_NATIVE_INDEXER_STRATEGY ?? "sqlite-direct").trim();
+    if (requested === "row-stream" || requested === "sqlite-bridge" || requested === "sqlite-direct")
+        return requested;
+    fail(`invalid PROJECT_LIBRARIAN_NATIVE_INDEXER_STRATEGY: ${requested}; expected row-stream, sqlite-bridge, or sqlite-direct`);
+}
+function appendTypeScriptPartitionToNativeDatabase(databasePath, files, parserMode) {
+    if (files.length === 0)
+        return 0;
+    const database = openDatabase(databasePath);
+    try {
+        const statements = (0, schema_1.createIndexStatements)(database);
+        database.exec("BEGIN");
+        for (const file of files)
+            indexCodeFile(readCodeFile(file.path, parserMode, file), statements);
+        database.exec("COMMIT");
+        return files.length;
+    }
+    catch (error) {
+        try {
+            database.exec("ROLLBACK");
+        }
+        catch {
+            // Ignore rollback failures after helper-created database errors.
+        }
+        throw error;
+    }
+    finally {
+        database.close();
+    }
+}
+function writeNativeRowsToDatabase(databasePath, rows, scopes, parserMode) {
+    removeDatabaseFiles(databasePath);
+    const database = openDatabase(databasePath);
+    try {
+        (0, schema_1.setupDatabase)(database, { secondaryIndexes: false });
+        const statements = (0, schema_1.createIndexStatements)(database);
+        database.exec("BEGIN");
+        statements.insertMeta.run("created_at", new Date().toISOString());
+        (0, schema_1.writeIndexMetadata)(scopes, parserMode, statements);
+        for (const file of rows.files) {
+            const ftsRowid = (0, schema_1.fileFtsRowid)(file.path);
+            statements.insertFile.run(file.path, ftsRowid, file.language, file.profile, file.kind, file.bytes, file.lines, file.hash, file.mtime_ms, file.size);
+            statements.insertFileFts.run(ftsRowid, file.path, file.language, file.profile, file.content);
+        }
+        for (const symbol of rows.symbols) {
+            statements.insertSymbol.run(symbol.name, symbol.kind, symbol.file_path, symbol.line, symbol.signature);
+            statements.insertSymbolFts.run(symbol.name, symbol.kind, symbol.file_path, symbol.signature);
+        }
+        for (const imported of rows.imports) {
+            statements.insertImport.run(imported.from_file, imported.to_ref, imported.imported, imported.line, imported.raw);
+        }
+        for (const route of rows.routes) {
+            statements.insertRoute.run(route.method, route.route, route.file_path, route.line, route.handler);
+        }
+        for (const config of rows.configs) {
+            statements.insertConfig.run(config.key, config.value, config.file_path, config.line);
+        }
+        for (const edge of rows.edges) {
+            statements.insertEdge.run(edge.kind, edge.source_kind, edge.source, edge.target_kind, edge.target, edge.file_path, edge.line, edge.evidence);
+        }
+        (0, schema_1.createSecondaryIndexes)(database);
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        try {
+            database.exec("ROLLBACK");
+        }
+        catch {
+            // Ignore rollback failures after row-stream setup errors.
+        }
+        throw error;
+    }
+    finally {
+        database.close();
+    }
+}
+function runNativeCodeIndexMode(request) {
+    let helperPath = "";
+    try {
+        helperPath = (0, native_helper_1.requireNativeCodeIndexHelperPath)();
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    prepareOutputPath();
+    const tempDatabasePath = `${request.databasePath.absolutePath}.native-${process.pid}-${Date.now()}.tmp`;
+    removeDatabaseFiles(tempDatabasePath);
+    const manifestFiles = [];
+    const nativeFiles = [];
+    const typescriptFiles = [];
+    for (const filePath of request.discoveredFiles) {
+        const file = nativeCodeIndexFileFor(filePath, request.parserMode);
+        manifestFiles.push(file);
+        if (nativeEligibleProfile(file.profile))
+            nativeFiles.push(file);
+        else
+            typescriptFiles.push(file);
+    }
+    const typescriptProfiles = [...new Set(typescriptFiles.map((file) => file.profile))].sort();
+    const outputMode = nativeCodeIndexOutputMode();
+    const rowsPath = `${tempDatabasePath}.rows.json`;
+    const job = (0, native_helper_1.buildNativeCodeIndexJob)({
+        database_path: tempDatabasePath,
+        files: nativeFiles,
+        output_mode: outputMode,
+        parser_mode: request.parserMode,
+        schema_version: schema_1.codeIndexSchemaVersion,
+        scopes: request.scopes,
+        ...(outputMode === "row-stream" ? { rows_path: rowsPath } : {}),
+    });
+    let summary;
+    let typescriptIndexedFiles = 0;
+    try {
+        if (outputMode === "row-stream") {
+            const result = (0, native_helper_1.runNativeCodeIndexRowsHelper)(job, { helperPath });
+            summary = result.summary;
+            writeNativeRowsToDatabase(tempDatabasePath, result.rows, request.scopes, request.parserMode);
+        }
+        else {
+            summary = (0, native_helper_1.runNativeCodeIndexHelper)(job, { helperPath });
+        }
+        if (!fs.existsSync(tempDatabasePath)) {
+            fail(`native code index helper did not create database: ${tempDatabasePath}`);
+        }
+        typescriptIndexedFiles = appendTypeScriptPartitionToNativeDatabase(tempDatabasePath, typescriptFiles, request.parserMode);
+        moveDatabaseFiles(tempDatabasePath, request.databasePath.absolutePath);
+    }
+    catch (error) {
+        removeTemporaryDatabaseFiles(tempDatabasePath);
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    finally {
+        if (fs.existsSync(rowsPath))
+            fs.unlinkSync(rowsPath);
+    }
+    console.log("Project wiki code evidence index complete.");
+    console.log(`database: ${request.databasePath.relativePath}`);
+    console.log("mode: full");
+    console.log(`parser_mode: ${request.parserMode}`);
+    console.log(`engine: ${typescriptIndexedFiles > 0 ? "mixed-native-rust" : "native-rust"}`);
+    if (request.requestedEngine === "auto")
+        console.log("engine_selection: auto");
+    console.log(`native_strategy: ${outputMode}`);
+    console.log(`scopes: ${request.scopes.join(", ")}`);
+    console.log(`files: ${manifestFiles.length}`);
+    console.log(`native_files: ${nativeFiles.length}`);
+    console.log(`typescript_files: ${typescriptIndexedFiles}`);
+    if (typescriptProfiles.length > 0)
+        console.log(`typescript_profiles: ${typescriptProfiles.join(", ")}`);
+    console.log(`reindexed_files: ${manifestFiles.length}`);
+    console.log(`deleted_files: ${summary.deleted_files ?? 0}`);
+    console.log(`unchanged_files: ${summary.unchanged_files ?? 0}`);
+}
+function runNativeCodeIndexIncrementalMode(request) {
+    let helperPath = "";
+    try {
+        helperPath = (0, native_helper_1.requireNativeCodeIndexHelperPath)();
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    const nativeFiles = request.reindexedFiles.map((file) => nativeCodeIndexFileFromFingerprint(file, request.parserMode));
+    const ineligibleProfiles = [...new Set(nativeFiles
+            .filter((file) => !nativeEligibleProfile(file.profile))
+            .map((file) => file.profile))].sort();
+    if (ineligibleProfiles.length > 0) {
+        fail(`native incremental writer does not support parser profiles: ${ineligibleProfiles.join(", ")}`);
+    }
+    prepareOutputPath();
+    const outputMode = "sqlite-direct";
+    const job = (0, native_helper_1.buildNativeCodeIndexJob)({
+        database_path: request.databasePath.absolutePath,
+        deleted_paths: request.deletedPaths,
+        files: nativeFiles,
+        mode: "incremental",
+        output_mode: outputMode,
+        parser_mode: request.parserMode,
+        schema_version: schema_1.codeIndexSchemaVersion,
+        scopes: request.scopes,
+    });
+    let summary;
+    try {
+        summary = (0, native_helper_1.runNativeCodeIndexHelper)(job, { helperPath });
+        if (!fs.existsSync(request.databasePath.absolutePath)) {
+            fail(`native incremental writer did not preserve database: ${request.databasePath.absolutePath}`);
+        }
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    console.log("Project wiki code evidence index complete.");
+    console.log(`database: ${request.databasePath.relativePath}`);
+    console.log("mode: incremental");
+    console.log(`parser_mode: ${request.parserMode}`);
+    console.log("engine: native-rust");
+    if (request.requestedEngine === "auto")
+        console.log("engine_selection: auto");
+    console.log(`native_strategy: ${outputMode}`);
+    console.log(`scopes: ${request.scopes.join(", ")}`);
+    console.log(`files: ${request.discoveredFiles.length}`);
+    console.log(`native_files: ${nativeFiles.length}`);
+    console.log("typescript_files: 0");
+    console.log(`reindexed_files: ${summary.reindexed_files ?? nativeFiles.length}`);
+    console.log(`deleted_files: ${summary.deleted_files ?? request.deletedPaths.length}`);
+    console.log(`unchanged_files: ${request.unchangedFiles}`);
+}
 function codeIndexStaleness(database) {
     const scopes = (0, schema_1.indexedScopes)(database);
     const parserMode = (0, schema_1.indexedParserMode)(database);
@@ -193,7 +538,7 @@ function codeIndexStaleness(database) {
         }
         if (existing.mtimeMs === file.mtimeMs && existing.size === file.size)
             continue;
-        if (readCodeFile(file.path, parserMode).hash !== existing.hash)
+        if (readCodeFile(file.path, parserMode, file).hash !== existing.hash)
             changed += 1;
     }
     const deleted = indexedRows.filter((row) => !currentPaths.has(String(row.path))).length;
@@ -383,7 +728,7 @@ function prepareOutputPath() {
     const databasePath = codeEvidenceDatabasePath();
     (0, workspace_1.mkdirp)(path.dirname(databasePath.relativePath));
     (0, workspace_1.mkdirp)(code_index_file_policy_1.codeEvidenceDirectory);
-    fs.writeFileSync((0, workspace_1.abs)(`${code_index_file_policy_1.codeEvidenceDirectory}/.gitignore`), "*\n!.gitignore\n");
+    (0, workspace_1.write)(`${code_index_file_policy_1.codeEvidenceDirectory}/.gitignore`, "*\n!.gitignore\n");
 }
 function codeIndexModeRuntime() {
     return {
@@ -396,13 +741,20 @@ function codeIndexModeRuntime() {
         codeScopes,
         fail,
         indexCodeFile,
+        nativeCodeIndexAvailable,
+        nativeCodeIndexIncrementalEligible,
         openDatabase,
         prepareOutputPath,
         readCodeFileFingerprint,
         readCodeFile,
         removeDatabaseFiles,
         requireExistingIndex,
+        runNativeCodeIndexIncrementalMode,
+        runNativeCodeIndexMode,
+        selectedCodeIndexEngine,
         selectedCodeParserMode,
+        codeIndexEngineSelectionContext,
+        shouldUseNativeCodeIndexAuto,
         warnIfCodeIndexStale,
     };
 }

package/dist/hooks.js

@@ -372,15 +372,15 @@ exports.gitPrepareCommitMsgHook = `#!/bin/sh
 MSG_FILE="$1"
 SOURCE="$2"
 
+# Security boundary: prepare-commit-msg runs before the commit is created, so it
+# must not execute scripts from the mutable worktree. Trailer generation remains
+# available as an explicit maintainer action, but this hook is intentionally
+# passive.
 case "$SOURCE" in
-  merge|squash|commit)
+  merge|squash|commit|*)
     exit 0
     ;;
 esac
-
-if command -v node >/dev/null 2>&1 && [ -f ".githooks/wiki-commit-trailers.js" ]; then
-  node .githooks/wiki-commit-trailers.js "$MSG_FILE"
-fi
 `;
 exports.gitWikiCommitTrailersScript = `#!/usr/bin/env node
 

package/dist/init-project-wiki.js

@@ -17,7 +17,7 @@ function codeIndex() {
 function printUsage() {
     console.log(`Usage:
   project-librarian [init|update] [options]
-  project-librarian install [--scope user|project] [--agents codex|claude|cursor|gemini|all]
+  project-librarian install [--scope user|project] [--agents codex|claude|cursor|gemini|all] [--dry-run]
   project-librarian mcp
 
 Options:
@@ -34,6 +34,7 @@ Options:
   --issue-draft                    Print a problem/side-effect GitHub issue body draft.
   --issue-body-file <path>         With --issue-create, use an existing Markdown body file.
   --issue-title <title>            Override the generated issue draft title.
+  --dry-run                        With install, preview copied skill files without writing them.
   --query <terms>                  Search wiki paths, metadata, titles, and bodies (answer-shaped, capped output).
   --wiki-impact <page-or-term>     Show wiki backlinks, decision_ref citations, and router depth for matching pages.
   --wiki-visualize                 Write a static wiki graph visualizer to .project-wiki/wiki-graph.html.
@@ -61,6 +62,7 @@ Options:
   --acknowledge-small-repo         With --code-index, proceed below the small-repo scale gate after its cost warning.
   --incremental                    With --code-index, require an existing compatible index and update only changes.
   --code-index-full                With --code-index, force a full rebuild even when incremental update is possible.
+  --code-index-engine <engine>     With --code-index, override default auto engine: typescript or native-rust.
   --code-parser <mode>             With --code-index, use parser mode default or tree-sitter.
   --code-query <sql>               Run conservative read-only SQL over the code evidence index.
   --code-status, --code-files      Inspect the code evidence index.
@@ -164,6 +166,10 @@ if (args_1.codeIndexFullMode && !args_1.codeIndexMode) {
     console.error("--code-index-full is only supported with --code-index.");
     process.exit(1);
 }
+if (args_1.codeIndexEngineMode && !args_1.codeIndexMode) {
+    console.error("--code-index-engine is only supported with --code-index.");
+    process.exit(1);
+}
 if (args_1.codeParserMode && !args_1.codeIndexMode) {
     console.error("--code-parser is only supported with --code-index.");
     process.exit(1);

package/dist/install-skill.js

@@ -112,26 +112,119 @@ function installTarget(agent, scope) {
     const base = scope === "user" ? userAgentRoot(agent) : path.join(process.cwd(), projectAgentRoot(agent));
     return path.join(base, "skills", skillName);
 }
+function assertNoTargetSymlink(targetRoot, target, includeLeaf) {
+    const rootResolved = path.resolve(targetRoot);
+    const targetResolved = path.resolve(target);
+    if (targetResolved !== rootResolved && !targetResolved.startsWith(`${rootResolved}${path.sep}`)) {
+        fail(`skill install target escaped target root: ${target}`);
+    }
+    if (fs.existsSync(rootResolved) && fs.lstatSync(rootResolved).isSymbolicLink()) {
+        fail("skill install refuses to follow destination symlink: .");
+    }
+    const relative = path.relative(rootResolved, targetResolved);
+    const parts = relative ? relative.split(path.sep).filter(Boolean) : [];
+    const checkedParts = includeLeaf ? parts : parts.slice(0, -1);
+    let current = rootResolved;
+    for (const part of checkedParts) {
+        current = path.join(current, part);
+        if (!fs.existsSync(current))
+            continue;
+        const stat = fs.lstatSync(current);
+        if (stat.isSymbolicLink()) {
+            fail(`skill install refuses to follow destination symlink: ${path.relative(rootResolved, current) || "."}`);
+        }
+        if (current !== targetResolved && !stat.isDirectory()) {
+            fail(`skill install target has a non-directory path component: ${path.relative(rootResolved, current)}`);
+        }
+    }
+}
+function isInsidePath(base, target) {
+    const baseResolved = path.resolve(base);
+    const targetResolved = path.resolve(target);
+    return targetResolved === baseResolved || targetResolved.startsWith(`${baseResolved}${path.sep}`);
+}
+function mkdirFromBaseNoSymlink(base, target) {
+    const baseResolved = path.resolve(base);
+    const targetResolved = path.resolve(target);
+    if (!isInsidePath(baseResolved, targetResolved)) {
+        fail(`skill install target escaped checked base: ${target}`);
+    }
+    let current = baseResolved;
+    const parts = path.relative(baseResolved, targetResolved).split(path.sep).filter(Boolean);
+    for (const part of parts) {
+        current = path.join(current, part);
+        if (fs.existsSync(current)) {
+            const stat = fs.lstatSync(current);
+            if (stat.isSymbolicLink()) {
+                fail(`skill install refuses to follow destination symlink: ${path.relative(baseResolved, current)}`);
+            }
+            if (!stat.isDirectory()) {
+                fail(`skill install target has a non-directory path component: ${path.relative(baseResolved, current)}`);
+            }
+            continue;
+        }
+        fs.mkdirSync(current);
+    }
+}
+function mkdirpNoTargetSymlink(targetRoot, target) {
+    const rootResolved = path.resolve(targetRoot);
+    const targetResolved = path.resolve(target);
+    const cwdResolved = path.resolve(process.cwd());
+    if (isInsidePath(cwdResolved, rootResolved)) {
+        mkdirFromBaseNoSymlink(cwdResolved, rootResolved);
+    }
+    else {
+        fs.mkdirSync(rootResolved, { recursive: true });
+    }
+    const relative = path.relative(rootResolved, targetResolved);
+    let current = rootResolved;
+    if (!relative) {
+        if (fs.existsSync(current) && fs.lstatSync(current).isSymbolicLink()) {
+            fail("skill install refuses to follow destination symlink: .");
+        }
+        if (!fs.existsSync(current))
+            fs.mkdirSync(current);
+        return;
+    }
+    for (const part of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, part);
+        if (fs.existsSync(current)) {
+            const stat = fs.lstatSync(current);
+            if (stat.isSymbolicLink()) {
+                fail(`skill install refuses to follow destination symlink: ${path.relative(rootResolved, current)}`);
+            }
+            if (!stat.isDirectory()) {
+                fail(`skill install target has a non-directory path component: ${path.relative(rootResolved, current)}`);
+            }
+            continue;
+        }
+        fs.mkdirSync(current);
+    }
+}
 function sameFile(source, target) {
-    if (!fs.existsSync(target) || !fs.statSync(target).isFile())
+    if (!fs.existsSync(target))
+        return false;
+    const stat = fs.lstatSync(target);
+    if (stat.isSymbolicLink() || !stat.isFile())
         return false;
     return fs.readFileSync(source).equals(fs.readFileSync(target));
 }
-function copyPath(source, target, dryRun) {
+function copyPath(source, target, targetRoot, dryRun) {
     if (!fs.existsSync(source))
         fail(`missing package file: ${source}`);
     const existed = fs.existsSync(target);
     if (dryRun)
         return "dry-run";
     const sourceStat = fs.statSync(source);
+    assertNoTargetSymlink(targetRoot, target, true);
     if (sourceStat.isDirectory()) {
-        fs.mkdirSync(target, { recursive: true });
+        mkdirpNoTargetSymlink(targetRoot, target);
         for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
-            copyPath(path.join(source, entry.name), path.join(target, entry.name), false);
+            copyPath(path.join(source, entry.name), path.join(target, entry.name), targetRoot, false);
         }
         return existed ? "updated" : "created";
     }
-    fs.mkdirSync(path.dirname(target), { recursive: true });
+    mkdirpNoTargetSymlink(targetRoot, path.dirname(target));
     if (sameFile(source, target))
         return "exists";
     fs.copyFileSync(source, target);
@@ -146,7 +239,7 @@ function copyPackageFiles(targetRoot, dryRun, labelRoot = targetRoot) {
     return packageFiles.map((relativePath) => {
         const source = path.join(root, relativePath);
         const target = path.join(targetRoot, relativePath);
-        return [path.join(labelRoot, relativePath), copyPath(source, target, dryRun)];
+        return [path.join(labelRoot, relativePath), copyPath(source, target, targetRoot, dryRun)];
     });
 }
 function syncProjectSkillInstall(agent) {

package/dist/mcp-server.js

@@ -1,10 +1,10 @@
 "use strict";
 // Hand-rolled MCP stdio server for the code-evidence index.
 //
-// Why hand-rolled: the product holds a zero-runtime-dependency posture (only
-// node:sqlite plus optional tree-sitter grammars). Adopting @modelcontextprotocol/sdk
-// would add a hard runtime dependency, so we implement the small slice of MCP we
-// need directly: JSON-RPC 2.0 over newline-delimited JSON on stdio.
+// Why hand-rolled: the package keeps the MCP surface dependency-light. Code
+// evidence already depends on node:sqlite, the package's TypeScript dependency,
+// and optional tree-sitter grammars; adopting @modelcontextprotocol/sdk would add
+// another hard runtime dependency for a small stdio slice.
 //
 // Transport: MCP stdio transport carries one JSON-RPC message per line on stdin
 // and stdout (newline-delimited JSON, "ndjson"); stderr is free for logging. We