gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/cli/skill-gen.js

@@ -8,6 +8,9 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
+const GENERATED_SKILL_PREFIX = 'gitnexus-area-';
+const MAX_SKILL_NAME_LENGTH = 64;
+const MAX_COMMUNITY_NAME_LENGTH = MAX_SKILL_NAME_LENGTH - GENERATED_SKILL_PREFIX.length;
 // ============================================================================
 // MAIN EXPORT
 // ============================================================================
@@ -20,7 +23,27 @@ import path from 'path';
  */
 export const generateSkillFiles = async (repoPath, projectName, pipelineResult) => {
     const { communityResult, processResult, graph } = pipelineResult;
-    const outputDir = path.join(repoPath, '.claude', 'skills', 'generated');
+    const outputDir = path.join(repoPath, '.claude', 'skills');
+    const legacyOutputDir = path.join(outputDir, 'generated');
+    // Community skills used to live under an undiscoverable `generated/`
+    // grouping directory. Clear that GitNexus-owned legacy output and
+    // stale direct outputs in the reserved namespace, while preserving every
+    // unrelated project skill under .claude/skills/.
+    try {
+        const entries = await fs.readdir(outputDir, { withFileTypes: true });
+        await Promise.all(entries
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith(GENERATED_SKILL_PREFIX))
+            .map((entry) => fs.rm(path.join(outputDir, entry.name), { recursive: true, force: true })));
+    }
+    catch {
+        /* output root may not exist yet */
+    }
+    try {
+        await fs.rm(legacyOutputDir, { recursive: true, force: true });
+    }
+    catch {
+        /* legacy output may not exist */
+    }
     if (!communityResult || !communityResult.memberships.length) {
         console.log('\n  Skills: no communities detected, skipping skill generation');
         return { skills: [], outputPath: outputDir };
@@ -47,13 +70,8 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
     // Step 3: Build lookup maps
     const membershipsByComm = buildMembershipMap(communityResult.memberships);
     const nodeIdToCommunityLabel = buildNodeCommunityLabelMap(communityResult.memberships, communities);
-    // Step 4: Clear and recreate output directory
-    try {
-        await fs.rm(outputDir, { recursive: true, force: true });
-    }
-    catch {
-        /* may not exist */
-    }
+    // Step 4: Ensure the shared project-skill root exists. Never clear it: it
+    // also contains user-authored and standard GitNexus skills.
     await fs.mkdir(outputDir, { recursive: true });
     // Step 5: Generate skill files
     const skills = [];
@@ -74,14 +92,15 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
         // Generate kebab name
         const kebabName = toKebabName(community.label, usedNames);
         usedNames.add(kebabName);
+        const skillName = `${GENERATED_SKILL_PREFIX}${kebabName}`;
         // Generate SKILL.md content
-        const content = renderSkillMarkdown(community, projectName, members, files, entryPoints, flows, connections, kebabName);
+        const content = renderSkillMarkdown(community, projectName, members, files, entryPoints, flows, connections, skillName);
         // Write file
-        const skillDir = path.join(outputDir, kebabName);
+        const skillDir = path.join(outputDir, skillName);
         await fs.mkdir(skillDir, { recursive: true });
         await fs.writeFile(path.join(skillDir, 'SKILL.md'), content, 'utf-8');
         const info = {
-            name: kebabName,
+            name: skillName,
             label: community.label,
             symbolCount: community.symbolCount,
             fileCount: files.length,
@@ -89,7 +108,7 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
         skills.push(info);
         console.log(`    \u2713 ${community.label} (${community.symbolCount} symbols, ${files.length} files)`);
     }
-    console.log(`\n  ${skills.length} skills generated \u2192 .claude/skills/generated/`);
+    console.log(`\n  ${skills.length} skills generated \u2192 .claude/skills/${GENERATED_SKILL_PREFIX}*/`);
     return { skills, outputPath: outputDir };
 };
 // ============================================================================
@@ -380,10 +399,10 @@ const gatherCrossConnections = (rawIds, ownLabel, membershipsByComm, nodeIdToCom
  * @param {MemberSymbol[]} entryPoints - Exported entry point symbols
  * @param {ProcessNode[]} flows - Execution flows touching this community
  * @param {CrossConnection[]} connections - Cross-community connections
- * @param {string} kebabName - Kebab-case name for the skill
+ * @param {string} skillName - Namespaced kebab-case name for the skill
  * @returns {string} Full SKILL.md content
  */
-const renderSkillMarkdown = (community, projectName, members, files, entryPoints, flows, connections, kebabName) => {
+const renderSkillMarkdown = (community, projectName, members, files, entryPoints, flows, connections, skillName) => {
     const cohesionPct = Math.round(community.cohesion * 100);
     // Dominant directory: most common top-level directory
     const dominantDir = getDominantDirectory(files);
@@ -396,7 +415,7 @@ const renderSkillMarkdown = (community, projectName, members, files, entryPoints
     const lines = [];
     // Frontmatter
     lines.push('---');
-    lines.push(`name: ${kebabName}`);
+    lines.push(`name: ${skillName}`);
     lines.push(`description: "Skill for the ${community.label} area of ${projectName}. ${community.symbolCount} symbols across ${files.length} files."`);
     lines.push('---');
     lines.push('');
@@ -496,20 +515,21 @@ const renderSkillMarkdown = (community, projectName, members, files, entryPoints
  * @brief Convert a community label to a kebab-case directory name
  * @param {string} label - The community label
  * @param {Set<string>} usedNames - Already-used names for collision detection
- * @returns {string} Unique kebab-case name capped at 50 characters
+ * @returns {string} Unique kebab-case name that leaves room for the GitNexus prefix
  */
 const toKebabName = (label, usedNames) => {
     let name = label
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '')
-        .slice(0, 50);
+        .slice(0, MAX_COMMUNITY_NAME_LENGTH);
     if (!name)
         name = 'skill';
     let candidate = name;
     let counter = 2;
     while (usedNames.has(candidate)) {
-        candidate = `${name}-${counter}`;
+        const suffix = `-${counter}`;
+        candidate = `${name.slice(0, MAX_COMMUNITY_NAME_LENGTH - suffix.length)}${suffix}`;
         counter++;
     }
     return candidate;

package/dist/cli/standard-skills.d.ts

@@ -0,0 +1,76 @@
+export type StandardSkillDistribution = 'project' | 'npm' | 'claudePlugin' | 'cursor';
+export interface StandardSkillCatalogEntry {
+    readonly name: `gitnexus-${string}`;
+    readonly agentTableTask: string;
+    readonly fallbackDescription: string;
+    readonly distributions: Readonly<Record<StandardSkillDistribution, boolean>>;
+}
+/**
+ * Canonical metadata for the standard skills installed by `gitnexus analyze`.
+ *
+ * Keep distribution intent here so generated agent guidance and drift guards
+ * cannot disagree about which copies should exist. The ordering intentionally
+ * matches the generated AGENTS.md / CLAUDE.md task table.
+ */
+export declare const STANDARD_SKILL_CATALOG: readonly [{
+    readonly name: "gitnexus-exploring";
+    readonly agentTableTask: "Understand architecture / \"How does X work?\"";
+    readonly fallbackDescription: "Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: \"How does X work?\", \"What calls this function?\", \"Show me the auth flow\"";
+    readonly distributions: {
+        readonly project: true;
+        readonly npm: true;
+        readonly claudePlugin: true;
+        readonly cursor: true;
+    };
+}, {
+    readonly name: "gitnexus-impact-analysis";
+    readonly agentTableTask: "Blast radius / \"What breaks if I change X?\"";
+    readonly fallbackDescription: "Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: \"Is it safe to change X?\", \"What depends on this?\", \"What will break?\"";
+    readonly distributions: {
+        readonly project: true;
+        readonly npm: true;
+        readonly claudePlugin: true;
+        readonly cursor: true;
+    };
+}, {
+    readonly name: "gitnexus-debugging";
+    readonly agentTableTask: "Trace bugs / \"Why is X failing?\"";
+    readonly fallbackDescription: "Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: \"Why is X failing?\", \"Where does this error come from?\", \"Trace this bug\"";
+    readonly distributions: {
+        readonly project: true;
+        readonly npm: true;
+        readonly claudePlugin: true;
+        readonly cursor: true;
+    };
+}, {
+    readonly name: "gitnexus-refactoring";
+    readonly agentTableTask: "Rename / extract / split / refactor";
+    readonly fallbackDescription: "Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: \"Rename this function\", \"Extract this into a module\", \"Refactor this class\", \"Move this to a separate file\"";
+    readonly distributions: {
+        readonly project: true;
+        readonly npm: true;
+        readonly claudePlugin: true;
+        readonly cursor: true;
+    };
+}, {
+    readonly name: "gitnexus-guide";
+    readonly agentTableTask: "Tools, resources, schema reference";
+    readonly fallbackDescription: "Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: \"What GitNexus tools are available?\", \"How do I use GitNexus?\"";
+    readonly distributions: {
+        readonly project: true;
+        readonly npm: true;
+        readonly claudePlugin: true;
+        readonly cursor: false;
+    };
+}, {
+    readonly name: "gitnexus-cli";
+    readonly agentTableTask: "Index, status, clean, wiki CLI commands";
+    readonly fallbackDescription: "Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: \"Index this repo\", \"Reanalyze the codebase\", \"Generate a wiki\"";
+    readonly distributions: {
+        readonly project: true;
+        readonly npm: true;
+        readonly claudePlugin: true;
+        readonly cursor: false;
+    };
+}];
+export type StandardSkillName = (typeof STANDARD_SKILL_CATALOG)[number]['name'];

package/dist/cli/standard-skills.js

@@ -0,0 +1,45 @@
+/**
+ * Canonical metadata for the standard skills installed by `gitnexus analyze`.
+ *
+ * Keep distribution intent here so generated agent guidance and drift guards
+ * cannot disagree about which copies should exist. The ordering intentionally
+ * matches the generated AGENTS.md / CLAUDE.md task table.
+ */
+export const STANDARD_SKILL_CATALOG = [
+    {
+        name: 'gitnexus-exploring',
+        agentTableTask: 'Understand architecture / "How does X work?"',
+        fallbackDescription: 'Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: "How does X work?", "What calls this function?", "Show me the auth flow"',
+        distributions: { project: true, npm: true, claudePlugin: true, cursor: true },
+    },
+    {
+        name: 'gitnexus-impact-analysis',
+        agentTableTask: 'Blast radius / "What breaks if I change X?"',
+        fallbackDescription: 'Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: "Is it safe to change X?", "What depends on this?", "What will break?"',
+        distributions: { project: true, npm: true, claudePlugin: true, cursor: true },
+    },
+    {
+        name: 'gitnexus-debugging',
+        agentTableTask: 'Trace bugs / "Why is X failing?"',
+        fallbackDescription: 'Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: "Why is X failing?", "Where does this error come from?", "Trace this bug"',
+        distributions: { project: true, npm: true, claudePlugin: true, cursor: true },
+    },
+    {
+        name: 'gitnexus-refactoring',
+        agentTableTask: 'Rename / extract / split / refactor',
+        fallbackDescription: 'Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file"',
+        distributions: { project: true, npm: true, claudePlugin: true, cursor: true },
+    },
+    {
+        name: 'gitnexus-guide',
+        agentTableTask: 'Tools, resources, schema reference',
+        fallbackDescription: 'Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: "What GitNexus tools are available?", "How do I use GitNexus?"',
+        distributions: { project: true, npm: true, claudePlugin: true, cursor: false },
+    },
+    {
+        name: 'gitnexus-cli',
+        agentTableTask: 'Index, status, clean, wiki CLI commands',
+        fallbackDescription: 'Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: "Index this repo", "Reanalyze the codebase", "Generate a wiki"',
+        distributions: { project: true, npm: true, claudePlugin: true, cursor: false },
+    },
+];

package/dist/cli/status.d.ts

@@ -3,4 +3,7 @@
  *
  * Shows the indexing status of the current repository.
  */
-export declare const statusCommand: () => Promise<void>;
+export interface StatusOptions {
+    json?: boolean;
+}
+export declare const statusCommand: (options?: StatusOptions) => Promise<void>;

package/dist/cli/status.js

@@ -5,11 +5,17 @@
  */
 import path from 'path';
 import { findRepo, getStoragePaths, loadMeta, hasKuzuIndex } from '../storage/repo-manager.js';
-import { getCurrentCommit, getCurrentBranch, isGitRepo, getGitRoot } from '../storage/git.js';
+import { getCurrentCommit, getCurrentBranch, isGitRepo, getGitRoot, isWorkingTreeDirty, } from '../storage/git.js';
+import { analyzerRunnerIdentitiesEqual, resolveAnalyzerRunnerIdentity, } from '../core/analyzer-identity.js';
+import { getIndexIncompleteReasons } from '../core/index-freshness.js';
 import { t } from './i18n/index.js';
-export const statusCommand = async () => {
+export const statusCommand = async (options = {}) => {
     const cwd = process.cwd();
     if (!isGitRepo(cwd)) {
+        if (options.json) {
+            console.log(JSON.stringify({ schemaVersion: 1, error: 'not-git-repository' }));
+            return;
+        }
         console.log(t('status.notGitRepo'));
         return;
     }
@@ -18,7 +24,16 @@ export const statusCommand = async () => {
         // Check if there's a stale KuzuDB index that needs migration
         const repoRoot = getGitRoot(cwd) ?? cwd;
         const { storagePath } = getStoragePaths(repoRoot);
-        if (await hasKuzuIndex(storagePath)) {
+        const staleKuzu = await hasKuzuIndex(storagePath);
+        if (options.json) {
+            console.log(JSON.stringify({
+                schemaVersion: 1,
+                repository: repoRoot,
+                error: staleKuzu ? 'stale-kuzu-index' : 'not-indexed',
+            }));
+            return;
+        }
+        if (staleKuzu) {
             console.log(t('status.staleKuzu'));
             console.log(t('status.rebuildLadybug'));
         }
@@ -45,14 +60,52 @@ export const statusCommand = async () => {
         else
             workspaceLagsBranch = true;
     }
+    const currentRunnerIdentity = resolveAnalyzerRunnerIdentity(import.meta.url);
+    const runnerIdentityIsCurrent = analyzerRunnerIdentitiesEqual(activeMeta.runnerIdentity, currentRunnerIdentity);
+    const incompleteReasons = getIndexIncompleteReasons(activeMeta);
+    // A matching HEAD is not enough: `analyze` re-indexes a dirty working tree,
+    // so a repo with uncommitted source changes is stale even at the same commit.
+    // Skip the check for non-git folders (currentCommit === '') to match analyze.
+    const isUpToDate = currentCommit === activeMeta.lastCommit &&
+        runnerIdentityIsCurrent &&
+        incompleteReasons.length === 0 &&
+        (currentCommit === '' || !isWorkingTreeDirty(repo.repoPath));
+    if (options.json) {
+        console.log(JSON.stringify({
+            schemaVersion: 1,
+            repository: repo.repoPath,
+            branch: currentBranch,
+            workspaceIndexBranch: workspaceLagsBranch ? (repo.meta.branch ?? null) : null,
+            index: {
+                indexedAt: activeMeta.indexedAt,
+                commit: activeMeta.lastCommit,
+                runnerIdentity: activeMeta.runnerIdentity ?? null,
+                runnerIdentityStatus: runnerIdentityIsCurrent ? 'current' : 'stale-or-unknown',
+                incompleteReasons,
+            },
+            current: {
+                commit: currentCommit,
+                runnerIdentity: currentRunnerIdentity,
+            },
+            status: isUpToDate ? 'up-to-date' : 'stale',
+        }));
+        return;
+    }
     console.log(`${t('status.repository')}: ${repo.repoPath}`);
     console.log(`${t('status.branch')}: ${currentBranch ?? t('status.detached')}`);
     if (workspaceLagsBranch) {
         console.log(t('status.workspaceIndexLabel', { primary: repo.meta.branch ?? '' }));
     }
-    const isUpToDate = currentCommit === activeMeta.lastCommit;
     console.log(`${t('status.indexed')}: ${new Date(activeMeta.indexedAt).toLocaleString()}`);
     console.log(`${t('status.indexedCommit')}: ${activeMeta.lastCommit?.slice(0, 7)}`);
     console.log(`${t('status.currentCommit')}: ${currentCommit?.slice(0, 7)}`);
+    // Emit the complete, versioned receipt as JSON so humans can inspect it and
+    // automation can compare it without reverse-engineering a display string.
+    // `null` is the backward-compatible signal for pre-receipt metadata.
+    console.log(`${t('status.indexRunnerIdentity')}: ${JSON.stringify(activeMeta.runnerIdentity ?? null)}`);
+    if (incompleteReasons.length > 0) {
+        console.log(`Index incomplete reasons: ${JSON.stringify(incompleteReasons)}`);
+    }
+    console.log(`${t('status.currentRunnerIdentity')}: ${JSON.stringify(currentRunnerIdentity)}`);
     console.log(`${t('status.status')}: ${isUpToDate ? t('status.upToDate') : t('status.stale')}`);
 };

package/dist/cli/tool.js

@@ -54,6 +54,17 @@ function output(data) {
         // Fallback: stderr (previous behavior, works on all platforms)
         process.stderr.write(text + '\n');
     }
+    // Backend failures come back as `{ error }` payloads rather than throws
+    // (#2469). Every tool command routes its result through here, so this is
+    // the one place that keeps scripted callers honest: print the payload,
+    // then exit non-zero.
+    if (data &&
+        typeof data === 'object' &&
+        'error' in data &&
+        typeof data.error === 'string' &&
+        data.error.trim().length > 0) {
+        process.exitCode = 1;
+    }
 }
 /**
  * Parse a `--limit` CLI option into a positive row cap, or `undefined` when the

package/dist/cli/uninstall.js

@@ -33,7 +33,8 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
 import { parseTree, modify, applyEdits, findNodeAtLocation, parse as parseJsonc, } from 'jsonc-parser';
-import { getEditorTargets, detectIndentation } from './editor-targets.js';
+import { getEditorTargets, detectIndentation, isEnoent } from './editor-targets.js';
+import { LEGACY_SKILL_DIR_NAMES } from './setup.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const execFileAsync = promisify(execFile);
@@ -50,7 +51,13 @@ async function removeJsoncKey(filePath, keyPath, dryRun) {
     try {
         raw = await fs.readFile(filePath, 'utf-8');
     }
-    catch {
+    catch (err) {
+        // ENOENT = genuinely not configured. Any other read failure (EACCES,
+        // locks) must not report 'missing' — the file may hold a real gitnexus
+        // entry the dry-run would then deny exists. Rethrow into the caller's
+        // per-file catch.
+        if (!isEnoent(err))
+            throw err;
         return 'missing';
     }
     if (raw.trim().length === 0)
@@ -88,7 +95,12 @@ async function removeHookEntries(filePath, eventNames, commandNeedle, dryRun) {
     try {
         raw = await fs.readFile(filePath, 'utf-8');
     }
-    catch {
+    catch (err) {
+        // Masking a non-ENOENT read failure as 'missing' would also let the
+        // caller delete the hook scriptDir while the unreadable settings file
+        // still references it. Rethrow into the hook uninstaller's catch.
+        if (!isEnoent(err))
+            throw err;
         return { status: 'missing', count: 0 };
     }
     if (raw.trim().length === 0)
@@ -166,13 +178,17 @@ async function removeDir(dirPath, dryRun) {
 /**
  * The exact set of skill directory names setup installs, derived from the
  * bundled `skills/` source the same way installSkillsTo does (flat
- * `{name}.md` and `{name}/SKILL.md` layouts). Deriving the set — rather
+ * `{name}.md` and `{name}/SKILL.md` layouts), plus the legacy names that
+ * older setups installed before a shipped rename. Deriving the set — rather
  * than globbing `gitnexus-*` — ensures we never delete a user's own
  * similarly-named skill folder.
  */
 async function listGitnexusSkillNames() {
     const skillsRoot = process.env.GITNEXUS_TEST_SKILLS_ROOT ?? path.join(__dirname, '..', '..', 'skills');
-    const names = new Set();
+    // Seed with legacy names superseded by shipped renames: they dropped out of
+    // the bundled source, but a pre-rename install left them behind in every
+    // target. Setup only warns about them; uninstall removes by name by design.
+    const names = new Set(LEGACY_SKILL_DIR_NAMES);
     try {
         const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
         for (const entry of entries) {
@@ -323,8 +339,15 @@ async function uninstallCodex(result, dryRun, configPath, tomlSection) {
     try {
         raw = await fs.readFile(configPath, 'utf-8');
     }
-    catch {
-        result.skipped.push('Codex MCP (not configured)');
+    catch (err) {
+        // Catch locally: this call site has no surrounding try, so a rethrow
+        // would abort the hooks/skills cleanup that runs after Codex.
+        if (isEnoent(err)) {
+            result.skipped.push('Codex MCP (not configured)');
+        }
+        else {
+            result.errors.push(`Codex: ${err instanceof Error ? err.message : String(err)}`);
+        }
         return;
     }
     if (!raw.includes(`[${tomlSection}]`)) {
@@ -369,20 +392,50 @@ export const uninstallCommand = async (options) => {
         console.log('  Dry run — nothing will be changed. Re-run with --force to apply.');
         console.log('');
     }
-    const result = { removed: [], skipped: [], errors: [] };
+    const result = { removed: [], skipped: [], errors: [], corruptLegacy: false };
     // ─── MCP server entries (JSONC editors) ──────────────────────────
+    // Sweep legacyFiles too: setup writes into the first existing file of the
+    // editor's priority chain, so the gitnexus entry may live in a deprecated
+    // location (e.g. CodeBuddy's ~/.codebuddy/mcp.json).
     for (const target of targets.mcpJsonc) {
-        try {
-            const status = await removeJsoncKey(target.file, target.keyPath, dryRun);
-            if (status === 'removed')
-                result.removed.push(`${target.label} MCP server — ${target.keyPath.join('.')} in ${target.file}`);
-            else if (status === 'corrupt')
-                result.errors.push(`${target.label}: ${path.basename(target.file)} is corrupt — left untouched`);
-            else
-                result.skipped.push(`${target.label} MCP (not configured)`);
+        let removedAny = false;
+        let erroredAny = false;
+        let corruptLegacyAny = false;
+        for (const file of [target.file, ...(target.legacyFiles ?? [])]) {
+            try {
+                const status = await removeJsoncKey(file, target.keyPath, dryRun);
+                if (status === 'removed') {
+                    removedAny = true;
+                    result.removed.push(`${target.label} MCP server — ${target.keyPath.join('.')} in ${file}`);
+                }
+                else if (status === 'corrupt') {
+                    if (file === target.file) {
+                        // The primary path is where gitnexus itself writes — corruption
+                        // there is an error worth failing the command over.
+                        erroredAny = true;
+                        result.errors.push(`${target.label}: ${path.basename(file)} is corrupt — left untouched`);
+                    }
+                    else {
+                        // Legacy chain files are vendor locations gitnexus may never have
+                        // touched (e.g. a corrupt ~/.codebuddy.json from an old install).
+                        // Report informationally without failing uninstall. Deliberate
+                        // asymmetry: an UNREADABLE (non-ENOENT) legacy file still errors —
+                        // that's an environmental problem worth surfacing, while corrupt-
+                        // but-readable proves there is no removable gitnexus entry.
+                        corruptLegacyAny = true;
+                        result.corruptLegacy = true;
+                        result.skipped.push(`${target.label} MCP (legacy ${path.basename(file)} is corrupt — left untouched)`);
+                    }
+                }
+            }
+            catch (err) {
+                erroredAny = true;
+                result.errors.push(`${target.label}: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
-        catch (err) {
-            result.errors.push(`${target.label}: ${err.message}`);
+        // A corrupt legacy file makes "not configured" unknowable — suppress it.
+        if (!removedAny && !erroredAny && !corruptLegacyAny) {
+            result.skipped.push(`${target.label} MCP (not configured)`);
         }
     }
     await uninstallCodex(result, dryRun, targets.codex.configFile, targets.codex.tomlSection);
@@ -425,6 +478,12 @@ export const uninstallCommand = async (options) => {
         for (const name of result.removed)
             console.log(`    - ${name}`);
     }
+    else if (result.errors.length > 0 || result.corruptLegacy) {
+        // Errors (corrupt primary files, unreadable configs) or corrupt legacy
+        // configs make "not configured" unknowable — claiming it right above an
+        // Errors block would be a contradiction users learn to distrust.
+        console.log('  Nothing removed.');
+    }
     else {
         console.log('  Nothing to remove — GitNexus is not configured in any detected editor.');
     }

package/dist/cli/wiki.d.ts

@@ -20,5 +20,6 @@ export interface WikiCommandOptions {
     timeout?: string;
     retries?: string;
     lang?: string;
+    allowInsecureConnection?: string;
 }
 export declare const wikiCommand: (inputPath?: string, options?: WikiCommandOptions) => Promise<void>;

package/dist/cli/wiki.js

@@ -11,7 +11,7 @@ import cliProgress from 'cli-progress';
 import { getGitRoot, isGitRepo } from '../storage/git.js';
 import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig, } from '../storage/repo-manager.js';
 import { WikiGenerator } from '../core/wiki/generator.js';
-import { resolveLLMConfig } from '../core/wiki/llm-client.js';
+import { parseLLMAllowedInsecureHttpHosts, resolveLLMConfig, } from '../core/wiki/llm-client.js';
 import { detectCursorCLI } from '../core/wiki/cursor-client.js';
 import { detectLocalCLI } from '../core/wiki/local-cli-client.js';
 import { logger } from '../core/logger.js';
@@ -152,9 +152,14 @@ const wikiCommandImpl = async (inputPath, options) => {
     }
     let timeoutSeconds;
     let retries;
+    let allowedInsecureHttpHosts;
     try {
         timeoutSeconds = parsePositiveIntegerOption(options?.timeout, '--timeout', 1000);
         retries = parsePositiveIntegerOption(options?.retries, '--retries');
+        allowedInsecureHttpHosts =
+            options?.allowInsecureConnection === undefined
+                ? undefined
+                : parseLLMAllowedInsecureHttpHosts(options.allowInsecureConnection);
     }
     catch (error) {
         console.log(`  Error: ${error.message}\n`);
@@ -210,6 +215,7 @@ const wikiCommandImpl = async (inputPath, options) => {
         provider: options?.provider,
         apiVersion: options?.apiVersion,
         isReasoningModel: options?.reasoningModel,
+        allowedInsecureHttpHosts,
     });
     // Run interactive setup if no saved config and no CLI flags provided
     // (even if env vars exist — let user explicitly choose their provider)

package/dist/config/ignore-service.d.ts

@@ -10,6 +10,8 @@ export declare const isHardcodedIgnoredDirectory: (name: string) => boolean;
 export interface IgnoreOptions {
     /** Skip .gitignore parsing, only read .gitnexusignore. Defaults to GITNEXUS_NO_GITIGNORE env var. */
     noGitignore?: boolean;
+    /** Skip core.excludesFile and $GIT_COMMON_DIR/info/exclude. Defaults to GITNEXUS_NO_GLOBAL_IGNORE env var. */
+    noGlobalIgnore?: boolean;
 }
 export declare const loadIgnoreRules: (repoPath: string, options?: IgnoreOptions) => Promise<Ignore | null>;
 /**

package/dist/config/ignore-service.js

@@ -2,6 +2,7 @@ import ignore from 'ignore';
 import fs from 'fs/promises';
 import nodePath from 'path';
 import { logger } from '../core/logger.js';
+import { getCoreExcludesFilePath, getGitInfoExcludePath } from '../storage/git.js';
 const DEFAULT_IGNORE_LIST = new Set([
     // Version Control
     '.git',
@@ -312,6 +313,32 @@ export const isHardcodedIgnoredDirectory = (name) => {
 export const loadIgnoreRules = async (repoPath, options) => {
     const ig = ignore();
     let hasRules = false;
+    // Mirror git's own precedence for ignore sources (gitignore(5)): patterns
+    // from core.excludesFile are consulted first (lowest precedence — git's
+    // real global, all-repos file), then $GIT_COMMON_DIR/info/exclude
+    // (per-repo, untracked — no write access to the repo needed), then
+    // .gitignore/.gitnexusignore below. Later ig.add() calls win on
+    // conflicting patterns, matching git's own last-match-wins semantics (#2606).
+    const skipGlobalIgnore = options?.noGlobalIgnore ?? !!process.env.GITNEXUS_NO_GLOBAL_IGNORE;
+    if (!skipGlobalIgnore) {
+        const globalSources = [
+            getCoreExcludesFilePath(repoPath),
+            getGitInfoExcludePath(repoPath),
+        ].filter((candidate) => candidate !== null);
+        for (const sourcePath of globalSources) {
+            try {
+                const content = await fs.readFile(sourcePath, 'utf-8');
+                ig.add(content);
+                hasRules = true;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== 'ENOENT') {
+                    logger.warn(`  Warning: could not read ${sourcePath}: ${err.message}`);
+                }
+            }
+        }
+    }
     // Allow users to bypass .gitignore parsing (e.g. when .gitignore accidentally excludes source files)
     const skipGitignore = options?.noGitignore ?? !!process.env.GITNEXUS_NO_GITIGNORE;
     const filenames = skipGitignore ? ['.gitnexusignore'] : ['.gitignore', '.gitnexusignore'];

package/dist/core/analysis-features.d.ts

@@ -0,0 +1,21 @@
+/** A durable statement that one analysis capability was produced by this build. */
+export interface AnalysisFeatureDescriptor {
+    readonly id: string;
+    readonly version: number;
+    readonly appliesTo: (filePaths: readonly string[]) => boolean;
+}
+export type AnalysisFeatureVersions = Readonly<Record<string, number>>;
+/**
+ * The Class table shape is global even when a repository contains no JVM code.
+ * Existing v8 indexes predate the frameworkAnnotations column and therefore
+ * need one full rebuild before any incremental Class write can be safe.
+ */
+export declare const CLASS_FRAMEWORK_ANNOTATIONS_FEATURE: AnalysisFeatureDescriptor;
+/** Resolve the exact feature set this build promises for the supplied files. */
+export declare function resolveAnalysisFeatureVersions(descriptors: readonly AnalysisFeatureDescriptor[], filePaths: readonly string[]): Record<string, number>;
+/**
+ * Compare an untrusted metadata value with the exact capabilities produced by
+ * this build. Extra keys also mismatch: a rollback must rebuild instead of
+ * certifying graph semantics emitted only by a newer binary.
+ */
+export declare function findAnalysisFeatureMismatches(actual: unknown, expected: AnalysisFeatureVersions): readonly string[];