@codragraph/cli 2.1.5 → 2.2.0-rc.6

package/README.md

@@ -25,12 +25,15 @@ That's it. This indexes the codebase, installs agent skills, registers Claude Co
 
 The same CLI commands work in Windows PowerShell, macOS bash/zsh, and Linux shells. Use `npx @codragraph/cli ...` for no-install runs or `codragraph ...` after a global install.
 
-Smart analyze rebuilds when indexed source, Markdown/MDX graph docs, language
-config, schema, compression, or requested embedding settings changed. Generated
-agent context, lockfile-only, and ignored asset changes reuse the existing
-graph and advance metadata. Each pass refreshes `.codragraph/structure/`, a
-compact what/why/how/when/where markdown pack with branch/index state, bounded
-history, and SQLite seed SQL for external agent memory.
+Smart analyze now patches the existing graph for normal day-to-day changes:
+source edits, renames, large diffs, and topology-only files replace only the
+affected file-scoped rows, then recompute communities, execution flows, and
+FeatureCluster packs. Package/config or ignore-rule inputs refresh all
+file-scoped rows without falling back to a full cold rebuild. Generated agent
+context, lockfile-only, and ignored asset changes reuse the existing graph and
+advance metadata. Each pass refreshes `.codragraph/structure/`, a compact
+what/why/how/when/where markdown pack with branch/index state, bounded history,
+and SQLite seed SQL for external agent memory.
 
 To configure MCP for your editor, run `npx @codragraph/cli setup` once — or set it up manually below.
 
@@ -62,16 +65,16 @@ If you prefer to configure manually instead of using `codragraph setup`:
 
 ```bash
 # macOS / Linux
-claude mcp add codragraph -- npx -y @codragraph/cli@2.1.5 mcp
+claude mcp add codragraph -- npx -y @codragraph/cli@2.2.0-rc.6 mcp
 
 # Windows
-claude mcp add codragraph -- cmd /c npx -y @codragraph/cli@2.1.5 mcp
+claude mcp add codragraph -- cmd /c npx -y @codragraph/cli@2.2.0-rc.6 mcp
 ```
 
 ### Codex (full support — MCP + skills)
 
 ```bash
-codex mcp add codragraph -- npx -y @codragraph/cli@2.1.5 mcp
+codex mcp add codragraph -- npx -y @codragraph/cli@2.2.0-rc.6 mcp
 ```
 
 ### Cursor / Windsurf
@@ -83,7 +86,7 @@ Add to `~/.cursor/mcp.json` (global — works for all projects):
   "mcpServers": {
     "codragraph": {
       "command": "npx",
-      "args": ["-y", "@codragraph/cli@2.1.5", "mcp"]
+      "args": ["-y", "@codragraph/cli@2.2.0-rc.6", "mcp"]
     }
   }
 }
@@ -98,7 +101,7 @@ Add to `~/.config/opencode/config.json`:
   "mcp": {
     "codragraph": {
       "command": "npx",
-      "args": ["-y", "@codragraph/cli@2.1.5", "mcp"]
+      "args": ["-y", "@codragraph/cli@2.2.0-rc.6", "mcp"]
     }
   }
 }
@@ -184,6 +187,8 @@ codragraph serve --web hosted      # API only; connect from hosted web UI
 codragraph index                   # Register an existing .codragraph/ folder into the global registry
 codragraph list                    # List all indexed repositories
 codragraph status                  # Show index status for current repo
+codragraph detect-changes --scope unstaged  # Map working-tree diff to symbols/processes
+codragraph detect-changes --scope all       # Include staged + unstaged changes
 codragraph clean                   # Delete index for current repo
 codragraph clean --all --force     # Delete all indexes
 codragraph wiki [path]             # Generate LLM-powered docs from knowledge graph
@@ -304,9 +309,9 @@ It is fixed in **codragraph v1.6.2+**. Upgrade to the current workspace
 version, or pin the version your team has validated:
 
 ```bash
-npx @codragraph/cli@2.1.5 analyze          # no global install
+npx @codragraph/cli@2.2.0-rc.6 analyze     # no global install
 # or
-npm install -g @codragraph/cli@2.1.5       # upgrade a global install
+npm install -g @codragraph/cli@2.2.0-rc.6  # upgrade a global install
 ```
 
 If you still hit npm install issues after upgrading, these generic workarounds

package/dist/cli/analyze.d.ts

@@ -7,9 +7,14 @@
  * This CLI wrapper handles: heap management, progress bar, SIGINT,
  * skill generation (--skills), summary output, and process.exit().
  */
+import { type AnalyzeProfileOption, type CompressionOption, type EmbeddingMode } from '../core/adaptive-profile.js';
 export interface AnalyzeOptions {
     force?: boolean;
     embeddings?: boolean;
+    /** Adaptive runtime profile. `auto` detects CPU/RAM/heap and chooses lean/balanced/power. */
+    profile?: AnalyzeProfileOption;
+    /** Embedding policy. `--embeddings` is kept as a shortcut for `on`. */
+    embeddingMode?: EmbeddingMode;
     skills?: boolean;
     verbose?: boolean;
     /** Skip AGENTS.md and CLAUDE.md codragraph block updates. */
@@ -54,12 +59,12 @@ export interface AnalyzeOptions {
      */
     skillTargets?: string;
     /**
-     * RFC 0001 Phase 2 — opt-in per-row content compression. Accepts
-     * `'none'` (default), `'brotli'` (Node ≥ 18), or `'zstd'` (Node ≥
-     * 22.15). Compressed indexes are still queryable via the standard
+     * RFC 0001 Phase 2 - per-row content compression. Accepts `'auto'`
+     * (default), `'none'`, `'brotli'` (Node >= 18), or `'zstd'`
+     * (Node >= 22.15). Compressed indexes are still queryable via the standard
      * read path; decode happens at every external-consumer boundary
      * (MCP, HTTP API, embeddings, CLI tools).
      */
-    compress?: 'none' | 'brotli' | 'zstd';
+    compress?: CompressionOption;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -17,6 +17,7 @@ import { closeCgdb } from '../core/cgdb/cgdb-adapter.js';
 import { getStoragePaths, getGlobalRegistryPath, RegistryNameCollisionError, } from '../storage/repo-manager.js';
 import { getGitRoot, hasGitDir } from '../storage/git.js';
 import { runFullAnalysis } from '../core/run-analyze.js';
+import { parseAnalyzeProfile, parseCompressionOption, parseEmbeddingMode, } from '../core/adaptive-profile.js';
 import { getMaxFileSizeBannerMessage } from '../core/ingestion/utils/max-file-size.js';
 import fs from 'fs/promises';
 import { formatBytes, LARGE_INDEX_WARNING_BYTES, summarizeIndexStorage } from './status.js';
@@ -28,10 +29,14 @@ const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
 /** Increase default stack size (KB) to prevent stack overflow on deep class hierarchies. */
 const STACK_KB = 4096;
 const STACK_FLAG = `--stack-size=${STACK_KB}`;
+function hasNodeFlag(flagName, nodeOpts, execArgv) {
+    return (nodeOpts.includes(flagName) ||
+        execArgv.some((arg) => arg === flagName || arg.startsWith(`${flagName}=`)));
+}
 /** Re-exec the process with an 8GB heap and larger stack if we're currently below that. */
 function ensureHeap() {
     const nodeOpts = process.env.NODE_OPTIONS || '';
-    if (nodeOpts.includes('--max-old-space-size'))
+    if (hasNodeFlag('--max-old-space-size', nodeOpts, process.execArgv))
         return false;
     const v8Heap = v8.getHeapStatistics().heap_size_limit;
     if (v8Heap >= HEAP_MB * 1024 * 1024 * 0.9)
@@ -39,10 +44,14 @@ function ensureHeap() {
     // --stack-size is a V8 flag not allowed in NODE_OPTIONS on Node 24+,
     // so pass it only as a direct CLI argument, not via the environment.
     const cliFlags = [HEAP_FLAG];
-    if (!nodeOpts.includes('--stack-size'))
+    if (!hasNodeFlag('--stack-size', nodeOpts, process.execArgv))
         cliFlags.push(STACK_FLAG);
     try {
-        execFileSync(process.execPath, [...cliFlags, ...process.argv.slice(1)], {
+        // Preserve loader/debug flags from the outer process. This is required
+        // for source-mode invocations such as `tsx src/cli/index.ts analyze`;
+        // otherwise the child runs plain node against .ts files and cannot
+        // resolve the emitted .js import specifiers.
+        execFileSync(process.execPath, [...process.execArgv, ...cliFlags, ...process.argv.slice(1)], {
             stdio: 'inherit',
             env: { ...process.env, NODE_OPTIONS: `${nodeOpts} ${HEAP_FLAG}`.trim() },
         });
@@ -58,18 +67,31 @@ export const analyzeCommand = async (inputPath, options) => {
     if (options?.verbose) {
         process.env.CODRAGRAPH_VERBOSE = '1';
     }
-    // RFC 0001 Phase 2 — validate --compress before doing any work. Catching
+    try {
+        parseAnalyzeProfile(options?.profile);
+        parseEmbeddingMode(options?.embeddingMode);
+    }
+    catch (err) {
+        console.error(`  ${err.message}`);
+        process.exitCode = 2;
+        return;
+    }
+    // RFC 0001 Phase 2 - validate --compress before doing any work. Catching
     // a typo or an unsupported encoding here is much friendlier than failing
     // mid-analyze with an opaque CSV-write error. Node-version gating for
     // zstd lives in @codragraph/graphstore via isEncodingSupported, but we
     // import the check here so the CLI can offer the brotli fallback hint.
-    if (options?.compress && options.compress !== 'none') {
-        if (options.compress !== 'brotli' && options.compress !== 'zstd') {
-            console.error(`  --compress must be one of: none, brotli, zstd (got: ${options.compress})`);
-            process.exitCode = 2;
-            return;
-        }
-        if (options.compress === 'zstd') {
+    const requestedCompress = options?.compress ?? 'auto';
+    try {
+        parseCompressionOption(requestedCompress);
+    }
+    catch (err) {
+        console.error(`  ${err.message}`);
+        process.exitCode = 2;
+        return;
+    }
+    if (requestedCompress !== 'auto' && requestedCompress !== 'none') {
+        if (requestedCompress === 'zstd') {
             const { isEncodingSupported } = await import('@codragraph/graphstore');
             if (!isEncodingSupported('zstd')) {
                 console.error('  --compress zstd requires Node ≥ 22.15.0 (native node:zlib zstd).\n' +
@@ -84,7 +106,7 @@ export const analyzeCommand = async (inputPath, options) => {
         // gracefully falls back to name-only matches instead of tokenising
         // base64 garbage. Surface the trade-off so users know what they're
         // opting into.
-        console.warn(`  Note: --compress ${options.compress} reduces .codragraph/cgdb size.\n` +
+        console.warn(`  Note: --compress ${requestedCompress} reduces .codragraph/cgdb size.\n` +
             `  BM25 search will index symbol names only (function bodies are not tokenised\n` +
             `  when compressed); embeddings, graph queries, and \`context\` / \`impact\` are\n` +
             `  unaffected. Run with --compress none if you rely on full-text search inside\n` +
@@ -241,8 +263,10 @@ export const analyzeCommand = async (inputPath, options) => {
             // cost of a full pipeline re-index. See #829 review round 2.
             allowDuplicateName: options?.allowDuplicateName,
             // RFC 0001 Phase 2 — pass through the per-row encoding choice.
-            // Default 'none' / undefined keeps the pre-Phase-2 wire layout.
+            // Default 'auto' lets the adaptive profile choose the storage tier.
             compress: options?.compress,
+            profile: options?.profile,
+            embeddingMode: options?.embeddingMode,
         }, {
             onProgress: (_phase, percent, message) => {
                 updateBar(percent, message);

package/dist/cli/graphpack.d.ts

@@ -0,0 +1,48 @@
+import { type GraphpackTarget } from '../core/graphpack/index.js';
+export declare const bootstrapCommand: (opts?: {
+    lock?: string;
+    artifactDir?: string;
+    materialize?: boolean;
+    json?: boolean;
+}) => Promise<void>;
+export declare const graphpackPublishCommand: (opts?: {
+    target?: GraphpackTarget;
+    repo?: string;
+    artifactDir?: string;
+    artifactUrl?: string;
+    baseSnapshot?: string;
+    headSnapshot?: string;
+    pr?: string;
+    json?: boolean;
+}) => Promise<void>;
+export declare const graphpackPullCommand: (opts?: {
+    lock?: string;
+    artifactDir?: string;
+    materialize?: boolean;
+    json?: boolean;
+}) => Promise<void>;
+export declare const graphpackStatusCommand: (opts?: {
+    lock?: string;
+    strict?: boolean;
+    json?: boolean;
+}) => Promise<void>;
+export declare const semanticAnalyzeCommand: (opts?: {
+    llm?: boolean;
+    limit?: string;
+    write?: boolean;
+    json?: boolean;
+}) => Promise<void>;
+export declare const recipesLookupCommand: (opts?: {
+    taskFamily?: string;
+    snapshotId?: string;
+    recipeStore?: string;
+    requiredSubgraphSignature?: string;
+    limit?: string;
+    json?: boolean;
+}) => Promise<void>;
+export declare const teamServeCommand: (opts?: {
+    graphpack?: string;
+    port?: string;
+    host?: string;
+    web?: string;
+}) => Promise<void>;

package/dist/cli/graphpack.js

@@ -0,0 +1,217 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { bootstrapGraphpack, getGraphpackStatus, publishGraphpack, pullGraphpack, } from '../core/graphpack/index.js';
+import { analyzeSemanticRelationships } from '../core/semantic/relationships.js';
+import { findRepo, getStoragePaths, registerRepo } from '../storage/repo-manager.js';
+import { getGitRoot, getInferredRepoName } from '../storage/git.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+const resolveRepoForGraphpack = async () => {
+    const indexed = await findRepo(process.cwd());
+    if (indexed) {
+        return {
+            repoPath: indexed.repoPath,
+            storagePath: indexed.storagePath,
+            repoName: getInferredRepoName(indexed.repoPath) ?? path.basename(indexed.repoPath),
+        };
+    }
+    const gitRoot = getGitRoot(process.cwd());
+    if (!gitRoot) {
+        throw new Error('Not inside a git repository and no CodraGraph index was found.');
+    }
+    const paths = getStoragePaths(gitRoot);
+    return {
+        repoPath: gitRoot,
+        storagePath: paths.storagePath,
+        repoName: getInferredRepoName(gitRoot) ?? path.basename(gitRoot),
+    };
+};
+export const bootstrapCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const result = await bootstrapGraphpack({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+        lockPath: opts.lock ? path.resolve(opts.lock) : undefined,
+        artifactDir: opts.artifactDir ? path.resolve(opts.artifactDir) : undefined,
+    });
+    await maybeRegisterRepo(repo);
+    if (opts.materialize !== false && result.materializable) {
+        await materializeGraphpackHead(result.status.lock?.graphpack.graphstoreHeadCommit);
+    }
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    printPullLikeResult('bootstrap', result);
+};
+export const graphpackPublishCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const result = await publishGraphpack({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+        repoName: opts.repo ?? repo.repoName,
+        analyzerVersion: pkg.version,
+        target: opts.target ?? 'main',
+        artifactDir: opts.artifactDir ? path.resolve(opts.artifactDir) : undefined,
+        artifactUrl: opts.artifactUrl,
+        baseSnapshotId: opts.baseSnapshot,
+        headSnapshotId: opts.headSnapshot,
+        pullRequest: opts.pr,
+    });
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write([
+        `graphpack: ${result.lock.graphpack.id}`,
+        `target: ${result.lock.graphpack.target}`,
+        `lock: ${result.lockPath}`,
+        `manifest: ${result.manifestPath}`,
+        `snapshot: ${result.lock.graphpack.graphstoreSnapshot ?? '(unknown)'}`,
+        `chunks: ${result.lock.chunks.length}`,
+    ].join('\n') + '\n');
+};
+export const graphpackPullCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const result = await pullGraphpack({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+        lockPath: opts.lock ? path.resolve(opts.lock) : undefined,
+        artifactDir: opts.artifactDir ? path.resolve(opts.artifactDir) : undefined,
+    });
+    await maybeRegisterRepo(repo);
+    if (opts.materialize !== false && result.materializable) {
+        await materializeGraphpackHead(result.status.lock?.graphpack.graphstoreHeadCommit);
+    }
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    printPullLikeResult('pull', result);
+};
+export const graphpackStatusCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const status = await getGraphpackStatus({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+        lockPath: opts.lock ? path.resolve(opts.lock) : undefined,
+        strict: opts.strict,
+    });
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+        return;
+    }
+    const lines = [
+        `source: ${status.source}`,
+        `lock: ${status.lockPresent ? status.lockPath : 'missing'}`,
+        `local_graphstore: ${status.local.graphstorePresent ? 'present' : 'missing'}`,
+        status.local.headCommit ? `local_head: ${status.local.headCommit}` : undefined,
+        status.lock?.graphpack.graphstoreSnapshot
+            ? `lock_snapshot: ${status.lock.graphpack.graphstoreSnapshot}`
+            : undefined,
+        `chunks: ${status.chunks.verified}/${status.chunks.expected} verified`,
+        `compatible: ${status.compatibility.ok ? 'yes' : 'no'}`,
+    ].filter(Boolean);
+    if (status.compatibility.reasons.length > 0) {
+        lines.push('reasons:');
+        for (const reason of status.compatibility.reasons)
+            lines.push(`  - ${reason}`);
+    }
+    if (status.chunks.missing.length > 0) {
+        lines.push('missing:');
+        for (const chunk of status.chunks.missing)
+            lines.push(`  - ${chunk}`);
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+};
+export const semanticAnalyzeCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const report = await analyzeSemanticRelationships({
+        storagePath: repo.storagePath,
+        llm: opts.llm,
+        write: opts.write !== false,
+        limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
+    });
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        return;
+    }
+    const lines = [
+        `snapshot: ${report.snapshotId ?? '(unknown)'}`,
+        `extractor: ${report.extractorVersion}`,
+        `llm: ${report.llmEnabled ? 'enabled' : 'disabled'}`,
+        `relationships: ${report.relationships.length}`,
+    ];
+    for (const [family, count] of Object.entries(report.summary)) {
+        if (count > 0)
+            lines.push(`  ${family}: ${count}`);
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+};
+export const recipesLookupCommand = async (opts = {}) => {
+    if (!opts.taskFamily)
+        throw new Error('recipes lookup requires --task-family <name>');
+    const repo = await resolveRepoForGraphpack();
+    const snapshotId = opts.snapshotId ??
+        (await getGraphpackStatus({ repoPath: repo.repoPath, storagePath: repo.storagePath })).lock
+            ?.graphpack.graphstoreSnapshot;
+    if (!snapshotId) {
+        throw new Error('recipes lookup requires --snapshot-id when no graphpack lock is available.');
+    }
+    const moduleId = '@codragraph/harness/mcp/handler';
+    const mod = (await import(/* @vite-ignore */ moduleId));
+    if (!mod.handleHarnessRecipesLookup) {
+        throw new Error('@codragraph/harness/mcp/handler does not export handleHarnessRecipesLookup');
+    }
+    const result = await mod.handleHarnessRecipesLookup({
+        task_family: opts.taskFamily,
+        snapshot_id: snapshotId,
+        recipe_store: opts.recipeStore ?? path.join(repo.storagePath, 'recipes'),
+        required_subgraph_signature: opts.requiredSubgraphSignature,
+        limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+};
+export const teamServeCommand = async (opts = {}) => {
+    const repo = await resolveRepoForGraphpack();
+    const status = await getGraphpackStatus({
+        repoPath: repo.repoPath,
+        storagePath: repo.storagePath,
+    });
+    if (opts.graphpack && status.lock?.graphpack.id !== opts.graphpack) {
+        throw new Error(`Requested graphpack ${opts.graphpack}, but lock points at ${status.lock?.graphpack.id ?? '(none)'}. Run graphpack pull or pass the matching id.`);
+    }
+    process.env.CODRAGRAPH_TEAM_GRAPH_MODE = '1';
+    process.env.CODRAGRAPH_ACTIVE_GRAPHPACK = opts.graphpack ?? status.lock?.graphpack.id ?? '';
+    const { serveCommand } = await import('./serve.js');
+    await serveCommand({ port: opts.port, host: opts.host, web: opts.web ?? 'hosted' });
+};
+const maybeRegisterRepo = async (repo) => {
+    const indexed = await findRepo(repo.repoPath);
+    if (!indexed?.meta)
+        return;
+    await registerRepo(repo.repoPath, indexed.meta);
+};
+const materializeGraphpackHead = async (headCommit) => {
+    if (!headCommit)
+        return;
+    const { checkoutCommand } = await import('./graphstore.js');
+    await checkoutCommand(headCommit, { materialize: true });
+};
+const printPullLikeResult = (label, result) => {
+    if (result.fallbackRequired) {
+        process.stdout.write([
+            `${label}: fallback required`,
+            `reason: ${result.reason ?? 'graphpack is not available locally'}`,
+            `fallback: ${result.fallbackCommand ?? 'codragraph analyze --skip-agents-md --no-setup'}`,
+        ].join('\n') + '\n');
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write([
+        `${label}: ok`,
+        `source: ${result.status.source}`,
+        `graphpack: ${result.status.lock?.graphpack.id ?? '(none)'}`,
+        `materializable: ${result.materializable ? 'yes' : 'no'}`,
+    ].join('\n') + '\n');
+};

package/dist/cli/index.js

@@ -37,7 +37,9 @@ program
     .command('analyze [path]')
     .description('Index a repository (full analysis)')
     .option('-f, --force', 'Force full re-index even if up to date')
-    .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
+    .option('--profile <mode>', 'Adaptive runtime profile: auto, lean, balanced, power', 'auto')
+    .option('--embedding-mode <mode>', 'Embedding policy: auto, off, on', 'auto')
+    .option('--embeddings', 'Enable embedding generation for semantic search (same as --embedding-mode on)')
     .option('--skills', 'Generate repo-specific skill files from detected communities')
     .option('--skill-targets <list>', 'CSV of editor targets for --skills (claude, cursor, opencode, codex). Default: claude.')
     .option('--skip-agents-md', 'Skip updating the codragraph section in AGENTS.md and CLAUDE.md')
@@ -50,7 +52,7 @@ program
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
     .option('--max-file-size <kb>', 'Skip files larger than this (KB). Default: 512. Hard cap: 32768 (tree-sitter limit).')
     .option('--no-setup', 'Skip the first-run editor setup (auto-runs once when ~/.codragraph/registry.json is missing)')
-    .option('--compress <encoding>', 'Compress per-row content (RFC 0001 Phase 2). One of: none (default), brotli, zstd. zstd requires Node ≥ 22.15.', 'none')
+    .option('--compress <encoding>', 'Compress per-row content. One of: auto (default), none, brotli, zstd. zstd requires Node >= 22.15.', 'auto')
     .addHelpText('after', '\nEnvironment variables:\n' +
     '  CODRAGRAPH_NO_GITIGNORE=1   Skip .gitignore parsing (still reads .codragraphignore)\n' +
     '  CODRAGRAPH_MAX_FILE_SIZE=N  Override large-file skip threshold (KB). Default 512, max 32768.\n' +
@@ -92,6 +94,14 @@ program
     .command('status')
     .description('Show index status for current repo')
     .action(createLazyAction(() => import('./status.js'), 'statusCommand'));
+program
+    .command('bootstrap')
+    .description('Bootstrap a local graph from .codragraph/index.lock.json when available')
+    .option('--lock <path>', 'Path to graphpack lock file')
+    .option('--artifact-dir <path>', 'Local graphpack artifact directory to pull from')
+    .option('--no-materialize', 'Validate/pull graphpack chunks without rebuilding the local cgdb')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'bootstrapCommand'));
 program
     .command('clean')
     .description('Delete CodraGraph index for current repo')
@@ -141,13 +151,17 @@ program
     .option('-r, --repo <name>', 'Target repository')
     .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)')
     .option('-f, --file <path>', 'File path to disambiguate common names')
+    .option('-k, --kind <kind>', 'Symbol kind to disambiguate common names')
     .option('--content', 'Include full symbol source code')
     .action(createOneShotLazyAction(() => import('./tool.js'), 'contextCommand'));
 program
-    .command('impact <target>')
+    .command('impact [target]')
     .description('Blast radius analysis: what breaks if you change a symbol')
     .option('-d, --direction <dir>', 'upstream (dependants) or downstream (dependencies)', 'upstream')
     .option('-r, --repo <name>', 'Target repository')
+    .option('-u, --uid <uid>', 'Direct target symbol UID (zero-ambiguity lookup)')
+    .option('-f, --file <path>', 'File path to disambiguate common names')
+    .option('-k, --kind <kind>', 'Symbol kind to disambiguate common names')
     .option('--depth <n>', 'Max relationship depth (default: 3)')
     .option('--include-tests', 'Include test files in results')
     .action(createOneShotLazyAction(() => import('./tool.js'), 'impactCommand'));
@@ -185,6 +199,7 @@ program
     .description('Generate the compact agent context pack for a feature cluster')
     .option('-r, --repo <name>', 'Target repository')
     .option('-l, --limit <n>', 'Max members to return (default: 100)')
+    .option('--compress <level>', 'Compression level: balanced, lean, or max')
     .action(createOneShotLazyAction(() => import('./tool.js'), 'contextPackCommand'));
 program
     .command('cluster-impact <name>')
@@ -209,6 +224,69 @@ program
     .option('--idle-timeout <seconds>', 'Auto-shutdown after N seconds idle (0 = disabled)', '0')
     .action(createLazyAction(() => import('./eval-server.js'), 'evalServerCommand'));
 registerGroupCommands(program);
+const graphpackCmd = program
+    .command('graphpack')
+    .description('Publish, pull, and inspect team graphpack artifacts');
+graphpackCmd
+    .command('publish')
+    .description('Publish a graphpack lock/manifest for main or PR artifact workflows')
+    .option('--target <target>', 'Graphpack target: main or pr', 'main')
+    .option('--repo <name>', 'Repository identity stored in the lock')
+    .option('--artifact-dir <path>', 'Local artifact staging directory')
+    .option('--artifact-url <url>', 'Remote artifact URL recorded in the lock')
+    .option('--base-snapshot <id>', 'PR overlay base snapshot id')
+    .option('--head-snapshot <id>', 'PR overlay head snapshot id')
+    .option('--pr <ref>', 'Pull request number or URL for overlay graphpacks')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'graphpackPublishCommand'));
+graphpackCmd
+    .command('pull')
+    .description('Pull graphpack chunks and prepare local materialization')
+    .option('--lock <path>', 'Path to graphpack lock file')
+    .option('--artifact-dir <path>', 'Local graphpack artifact directory to pull from')
+    .option('--no-materialize', 'Pull/validate without rebuilding the local cgdb')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'graphpackPullCommand'));
+graphpackCmd
+    .command('status', { isDefault: true })
+    .description('Show graphpack lock, chunk, and local materialization status')
+    .option('--lock <path>', 'Path to graphpack lock file')
+    .option('--strict', 'Recompute graphstore CAS digest instead of trusting local presence')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'graphpackStatusCommand'));
+const semanticCmd = program
+    .command('semantic')
+    .description('Analyze developer-intent semantic relationships above raw graph edges');
+semanticCmd
+    .command('analyze', { isDefault: true })
+    .description('Extract semantic relationship families with confidence and evidence')
+    .option('--llm', 'Allow optional LLM-inferred semantic edges when provider support is configured')
+    .option('--limit <n>', 'Maximum semantic relationships to return', '1000')
+    .option('--no-write', 'Do not write .codragraph/semantic-relationships.json')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'semanticAnalyzeCommand'));
+const recipesCmd = program
+    .command('recipes')
+    .description('Lookup graph-snapshot keyed harness recipes');
+recipesCmd
+    .command('lookup')
+    .description('Find reusable harness recipes for a task family and graph snapshot')
+    .requiredOption('--task-family <name>', 'Task family identifier')
+    .option('--snapshot-id <id>', 'Graph snapshot id. Defaults to graphpack lock snapshot.')
+    .option('--required-subgraph-signature <sig>', 'Subgraph signature needed by the task')
+    .option('--recipe-store <path>', 'Recipe store root')
+    .option('--limit <n>', 'Max entries per match kind', '10')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(createLazyAction(() => import('./graphpack.js'), 'recipesLookupCommand'));
+const teamCmd = program.command('team').description('Team graph server commands');
+teamCmd
+    .command('serve')
+    .description('Start hosted/team MCP-compatible HTTP mode for a graphpack')
+    .option('--graphpack <id>', 'Graphpack id to serve')
+    .option('-p, --port <port>', 'Port number', '4747')
+    .option('--host <host>', 'Bind address')
+    .option('--web <mode>', 'Dashboard mode: hosted, local, or off', 'hosted')
+    .action(createLazyAction(() => import('./graphpack.js'), 'teamServeCommand'));
 // ─── Config: unified API-key model (~/.codragraph/config.json) ─────
 const configCmd = program
     .command('config')

package/dist/cli/status.d.ts

@@ -13,7 +13,7 @@ export interface IndexStorageSummary {
 }
 export declare const formatBytes: (bytes: number) => string;
 export declare const summarizeIndexStorage: (storagePath: string) => Promise<IndexStorageSummary | null>;
-export declare const formatIndexStatusLines: (summary: IndexStorageSummary | null, meta: Pick<RepoMeta, "stats" | "compress">, options?: {
+export declare const formatIndexStatusLines: (summary: IndexStorageSummary | null, meta: Pick<RepoMeta, "stats" | "compress" | "adaptiveProfile">, options?: {
     largeIndexWarningBytes?: number;
 }) => string[];
 export declare const statusCommand: () => Promise<void>;

package/dist/cli/status.js

@@ -94,6 +94,14 @@ export const formatIndexStatusLines = (summary, meta, options = {}) => {
     const embeddings = meta.stats?.embeddings;
     lines.push(`Embeddings: ${typeof embeddings === 'number' ? embeddings.toLocaleString('en-US') : 'unknown'}`);
     lines.push(`Compression: ${meta.compress ?? 'none'}`);
+    if (meta.adaptiveProfile?.resolved) {
+        const profile = meta.adaptiveProfile;
+        const workerText = typeof profile.workerPoolSize === 'number' ? `, workers ${profile.workerPoolSize}` : '';
+        const embeddingText = profile.embeddingDecision
+            ? `, embeddings ${profile.embeddingDecision}`
+            : '';
+        lines.push(`Adaptive profile: ${profile.resolved}${workerText}${embeddingText}`);
+    }
     return lines;
 };
 export const statusCommand = async () => {