@shrkcrft/cli 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/main.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
-import { CommandRegistry, extractGlobalCwd, parseArgs, } from "./command-registry.js";
+import { loadDotenv } from "./env/load-dotenv.js";
+import { CommandRegistry, extractGlobalCompress, extractGlobalCwd, parseArgs, } from "./command-registry.js";
+import { runCommandWithCompression } from "./output/output-compression.js";
 import { initCommand } from "./commands/init.command.js";
 import { inspectCommand } from "./commands/inspect.command.js";
 import { doctorAcknowledgeCommand, doctorAcknowledgementsCommand, doctorCommand, doctorSuppressCommand, doctorSuppressionsCommand, } from "./commands/doctor.command.js";
@@ -20,10 +22,21 @@ import { presetsListCommand, presetsGetCommand, presetsExplainCommand, presetsRe
 import { taskCommand } from "./commands/task.command.js";
 import { preflightCommand } from "./commands/preflight.command.js";
 import { checkCommand } from "./commands/check.command.js";
+import { diffCheckCommand } from "./commands/diff-check.command.js";
 import { driftCommand } from "./commands/drift.command.js";
 import { graphCommand } from "./commands/graph.command.js";
+import { ruleGraphCommand } from "./commands/rule-graph-subverbs.js";
+import { searchStructuralCommand } from "./commands/search-structural.command.js";
+import { planContextCommand } from "./commands/plan-context.command.js";
+import { archCommand } from "./commands/arch.command.js";
+import { frameworkCommand } from "./commands/framework.command.js";
+import { apiDiffCommand } from "./commands/api-diff.command.js";
+import { gateCommand } from "./commands/gate.command.js";
+import { migrateCommand } from "./commands/migrate.command.js";
 import { coverageCommand } from "./commands/coverage.command.js";
 import { statsCommand } from "./commands/stats.command.js";
+import { compressCommand, expandCommand } from "./commands/compress.command.js";
+import { alignCommand, unalignCommand } from "./commands/cache-align.command.js";
 import { reviewCommand } from "./commands/review.command.js";
 import { onboardCommand } from "./commands/onboard.command.js";
 import { contradictionsCommand, generatedCommand, ingestCommand, } from "./commands/ingest.command.js";
@@ -37,6 +50,7 @@ import { contextCommand } from "./commands/context.command.js";
 import { diffParentCommand, diffRoundsCommand, roundsCaptureCommand, roundsListCommand, roundsParentCommand, roundsShowCommand, } from "./commands/rounds.command.js";
 import { genCommand } from "./commands/gen.command.js";
 import { applyCommand } from "./commands/apply.command.js";
+import { delegateCommand } from "./commands/delegate.command.js";
 import { groundingCommand } from "./commands/grounding.command.js";
 import { planCheckCommand } from "./commands/plan-check.command.js";
 import { whyCommand } from "./commands/why.command.js";
@@ -46,6 +60,13 @@ import { dashboardCommand } from "./commands/dashboard.command.js";
 import { dashboardDiffCommand, dashboardExportCommand, } from "./commands/dashboard-export.command.js";
 import { importCommand } from "./commands/import.command.js";
 import { askCommand } from "./commands/ask.command.js";
+import { aiStatusCommand } from "./commands/ai-status.command.js";
+import { smartContextAuditKnowledgeCommand, smartContextAuditPipelinesCommand, smartContextAuditTemplatesCommand, smartContextCommand, smartContextEmbeddingsBuildCommand, smartContextEmbeddingsStatusCommand, smartContextListCommand, smartContextPlanAheadCommand, smartContextShowCommand, } from "./commands/smart-context.command.js";
+import { spikeCommand } from "./commands/spike.command.js";
+import { depsAuditCommand } from "./commands/deps-audit.command.js";
+import { scaffoldValidateCommand } from "./commands/scaffold-validate.command.js";
+import { movePlanCommand } from "./commands/move-plan.command.js";
+import { watchCommand, watchListCommand, watchPruneCommand, watchStopCommand } from "./commands/watch.command.js";
 import { mcpCommand } from "./commands/mcp.command.js";
 import { versionCommand } from "./commands/version.command.js";
 import { makeHelpCommand } from "./commands/help.command.js";
@@ -56,7 +77,6 @@ import { biomeCommand } from "./commands/biome.command.js";
 import { ideCommand } from "./commands/ide.command.js";
 import { makeCommandsCommand } from "./commands/commands.command.js";
 import { safetyCommand } from "./commands/safety.command.js";
-import { pluginCommand } from "./commands/plugin.command.js";
 import { profilesCommand } from "./commands/profiles.command.js";
 import { auditProjectCouplingCommand } from "./commands/audit.command.js";
 import { conventionsCommand } from "./commands/conventions.command.js";
@@ -110,6 +130,8 @@ import { lintCommand } from "./commands/lint.command.js";
 import { changesCommand } from "./commands/changes.command.js";
 import { exploreCommand } from "./commands/explore.command.js";
 import { prCommand } from "./commands/pr.command.js";
+import { completionCommand } from "./commands/completion.command.js";
+import { codeIntelCommand } from "./commands/code-intel.command.js";
 import { suggestDidYouMean } from '@shrkcrft/inspector';
 import { COMMAND_CATALOG } from "./commands/command-catalog.js";
 import { errorFooterFor, renderErrorFooter } from "./output/failure-hints.js";
@@ -125,6 +147,7 @@ export function buildRegistry() {
     registry.register(initCommand);
     registry.register(inspectCommand);
     registry.register(doctorCommand);
+    registry.register(aiStatusCommand);
     registry.registerSubcommand('doctor', doctorSuppressCommand);
     registry.registerSubcommand('doctor', doctorSuppressionsCommand);
     // Acknowledgements with required reason + expiry.
@@ -133,6 +156,7 @@ export function buildRegistry() {
     registry.register(contextCommand);
     registry.register(genCommand);
     registry.register(applyCommand);
+    registry.register(delegateCommand);
     // `shrk grounding` thin context primer.
     registry.register(groundingCommand);
     // feedback3 — `shrk why <file>` (closes the dangling ide-suggested verb).
@@ -162,12 +186,25 @@ export function buildRegistry() {
     registry.register(taskCommand);
     registry.register(explainCommand);
     registry.register(checkCommand);
+    registry.register(diffCheckCommand);
     // changed-only preflight orchestrator.
     registry.register(preflightCommand);
     registry.register(driftCommand);
     registry.register(graphCommand);
+    registry.register(ruleGraphCommand);
+    registry.register(searchStructuralCommand);
+    registry.register(planContextCommand);
+    registry.register(archCommand);
+    registry.register(frameworkCommand);
+    registry.register(apiDiffCommand);
+    registry.register(gateCommand);
+    registry.register(migrateCommand);
     registry.register(coverageCommand);
     registry.register(statsCommand);
+    registry.register(compressCommand);
+    registry.register(expandCommand);
+    registry.register(alignCommand);
+    registry.register(unalignCommand);
     registry.register(reviewCommand);
     registry.register(onboardCommand);
     registry.register(ingestCommand);
@@ -185,6 +222,23 @@ export function buildRegistry() {
     registry.register(planParentCommand);
     registry.register(devCommand);
     registry.register(askCommand);
+    registry.register(smartContextCommand);
+    registry.registerSubcommand('smart-context', smartContextPlanAheadCommand);
+    registry.registerSubcommand('smart-context', smartContextListCommand);
+    registry.registerSubcommand('smart-context', smartContextShowCommand);
+    registry.registerSubcommand('smart-context', smartContextEmbeddingsBuildCommand);
+    registry.registerSubcommand('smart-context', smartContextEmbeddingsStatusCommand);
+    registry.registerSubcommand('smart-context', smartContextAuditTemplatesCommand);
+    registry.registerSubcommand('smart-context', smartContextAuditKnowledgeCommand);
+    registry.registerSubcommand('smart-context', smartContextAuditPipelinesCommand);
+    registry.register(spikeCommand);
+    registry.register(depsAuditCommand);
+    registry.register(scaffoldValidateCommand);
+    registry.register(movePlanCommand);
+    registry.register(watchCommand);
+    registry.registerSubcommand('watch', watchListCommand);
+    registry.registerSubcommand('watch', watchStopCommand);
+    registry.registerSubcommand('watch', watchPruneCommand);
     registry.register(mcpCommand);
     registry.register(versionCommand);
     registry.register(qualityCommand);
@@ -192,7 +246,6 @@ export function buildRegistry() {
     registry.register(eslintCommand);
     registry.register(biomeCommand);
     registry.register(ideCommand);
-    registry.register(pluginCommand);
     registry.register(profilesCommand);
     registry.registerSubcommand('audit', auditProjectCouplingCommand);
     registry.register(conventionsCommand);
@@ -213,6 +266,8 @@ export function buildRegistry() {
     registry.register(lintCommand);
     registry.register(changesCommand);
     registry.register(prCommand);
+    registry.register(completionCommand);
+    registry.register(codeIntelCommand);
     registry.register(searchCommand);
     registry.register(briefCommand);
     registry.register(releaseCommand);
@@ -493,8 +548,23 @@ async function isUsageEnabled(cwd) {
 async function runCliInner(argv) {
     const registry = buildRegistry();
     // Pre-parse the global --cwd so it can appear anywhere (incl. before the command).
-    const { cwd: globalCwd, rest: cleanArgv } = extractGlobalCwd(argv);
+    const { cwd: globalCwd, rest: cwdCleanArgv } = extractGlobalCwd(argv);
+    // Pre-parse the global --compress / --ccr output-compression flags.
+    const { directive: compressDirective, rest: cleanArgv } = extractGlobalCompress(cwdCleanArgv);
     const [first] = cleanArgv;
+    // `--compress` / `--ccr` on a real command: re-run it and compress its stdout.
+    // (Meta verbs like --help/--version and bare invocations are left untouched.)
+    if (compressDirective &&
+        first &&
+        first !== '--help' &&
+        first !== '-h' &&
+        first !== '--full-help' &&
+        first !== '--version' &&
+        first !== '-v' &&
+        first !== '--about') {
+        const childArgv = globalCwd ? ['--cwd', globalCwd, ...cleanArgv] : [...cleanArgv];
+        return runCommandWithCompression(childArgv, compressDirective, globalCwd ?? process.cwd());
+    }
     // bare invocation lands on the curated tiered view.
     if (!first) {
         const landing = await renderNoArgsLanding(globalCwd ?? process.cwd());
@@ -506,7 +576,14 @@ async function runCliInner(argv) {
         return registry.get('help').run(parseArgs([], { globalCwd }));
     }
     if (first === '--full-help') {
-        return registry.get('help').run(parseArgs(['--full'], { globalCwd }));
+        // Pass through `--all` (catalog dump) and `--verbose` if the user
+        // included them after `--full-help`.
+        const extra = [];
+        if (argv.includes('--all'))
+            extra.push('--all');
+        if (argv.includes('--verbose') || argv.includes('-v'))
+            extra.push('--verbose');
+        return registry.get('help').run(parseArgs(['--full', ...extra], { globalCwd }));
     }
     if (first === '--version' || first === '-v') {
         return registry.get('version').run(parseArgs([], { globalCwd }));
@@ -536,7 +613,7 @@ async function runCliInner(argv) {
             process.stderr.write(renderSurfaceNotEnabledText(err));
             return SURFACE_NOT_ENABLED_EXIT_CODE;
         }
-        return await handler.run(parseArgs(leftover, { globalCwd }));
+        return await handler.run(parseArgs(leftover, { globalCwd, booleanFlags: handler.booleanFlags }));
     }
     // No handler at the deepest match. If we landed on a group node (has
     // children), show that group's help so the user discovers the verbs.
@@ -550,7 +627,7 @@ async function runCliInner(argv) {
         return 2;
     }
     const attempted = probe.slice(0, 2).join(' ');
-    process.stderr.write(`Unknown command: ${attempted}\n`);
+    process.stderr.write(`shrk doesn't have a \`${attempted}\` command.\n`);
     printDidYouMean(attempted);
     return 2;
 }
@@ -567,7 +644,15 @@ async function runCliInner(argv) {
  * Exported for tests.
  */
 export function looksLikeFreeFormTask(tokens) {
-    const clean = tokens.filter((t) => t.length > 0 && !t.startsWith('-'));
+    // Flatten on internal whitespace so the canonical *quoted* form
+    // (`shrk "refactor the auth module"`) — which the shell delivers as ONE argv
+    // element — is counted by word, exactly like the unquoted multi-token form.
+    // Without this, the documented quoted form was a single token (length 1) and
+    // fell through to the did-you-mean matcher instead of routing to `recommend`.
+    const clean = tokens
+        .filter((t) => t.length > 0 && !t.startsWith('-'))
+        .flatMap((t) => t.trim().split(/\s+/))
+        .filter((w) => w.length > 0);
     if (clean.length < 2)
         return false;
     // 3+ tokens is almost always a sentence, not a command — `shrk` only has
@@ -658,25 +743,144 @@ async function checkSurfaceGate(matchedPath, cwd) {
         return null;
     }
 }
+// Score thresholds for did-you-mean output. Picked from observed
+// scoring: 1-char-off typos score 8+ on plain commands; 3-4-char-off
+// near-misses score ~5; loose / token-overlap matches score 1-3.
+// Junk matches (frobnicate → bundle diff) can score 8 too because of
+// token overlap, so we sharpen by also requiring the suggestion's
+// command name to be reasonably close in length to the attempt.
+const SUGGEST_CONFIDENT_SCORE = 7;
+const SUGGEST_VISIBLE_SCORE = 3;
+function reorderCandidates(attempted, candidates) {
+    // Stable sort: higher score first, then shorter command (more likely
+    // canonical), then lexicographic. The base suggester returns ties in
+    // arbitrary order — this makes the top suggestion more predictable.
+    const ranked = [...candidates];
+    ranked.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        if (a.command.length !== b.command.length) {
+            return a.command.length - b.command.length;
+        }
+        return a.command < b.command ? -1 : a.command > b.command ? 1 : 0;
+    });
+    return ranked;
+}
+/** Edit distance (Levenshtein). Used to gate did-you-mean confidence. */
+function editDistance(a, b) {
+    const m = a.length;
+    const n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = new Array(n + 1);
+    for (let j = 0; j <= n; j += 1)
+        dp[j] = j;
+    for (let i = 1; i <= m; i += 1) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= n; j += 1) {
+            const tmp = dp[j];
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + cost);
+            prev = tmp;
+        }
+    }
+    return dp[n];
+}
+/**
+ * Suggestion is "confident" when the candidate's top token is close
+ * to the attempt in edit-distance terms — `doctorz`→`doctor` (1 edit)
+ * or `inspct`→`inspect` (1 edit) qualify; `frobnicate`→`bundle` (10
+ * edits) does not, even when the suggester scores them similarly
+ * because of incidental token overlap in descriptions.
+ *
+ * Threshold: edit distance ≤ max(1, attempt.length / 4) AND raw score
+ * meets `SUGGEST_VISIBLE_SCORE`. This catches typical fingers-on-keys
+ * typos while rejecting "you typed something totally different."
+ */
+function isConfidentMatch(attempted, suggestion) {
+    if (suggestion.score < SUGGEST_VISIBLE_SCORE)
+        return false;
+    const lower = attempted.toLowerCase();
+    const head = (suggestion.command.split(/\s+/)[0] ?? suggestion.command).toLowerCase();
+    const dist = editDistance(lower, head);
+    const tolerance = Math.max(1, Math.floor(lower.length / 4));
+    return dist <= tolerance;
+}
 function printDidYouMean(attempted) {
-    const candidates = suggestDidYouMean(COMMAND_CATALOG, [attempted], 3);
-    if (candidates.length === 0) {
-        process.stderr.write("Tip: run `shrk commands suggest \"<partial>\"` or `shrk help` to discover commands.\n");
+    const rawCandidates = suggestDidYouMean(COMMAND_CATALOG, [attempted], 5);
+    const reordered = reorderCandidates(attempted, rawCandidates).filter((c) => c.score >= SUGGEST_VISIBLE_SCORE);
+    if (reordered.length === 0) {
+        process.stderr.write('Run `shrk help` to see the curated commands, or `shrk --full-help` for the full catalog.\n');
         const footer = errorFooterFor('unknown-command', { task: attempted });
         if (footer)
             process.stderr.write(renderErrorFooter(footer));
         return;
     }
-    process.stderr.write('Did you mean:\n');
-    for (const c of candidates) {
+    // Confident single-match path: surface ONE suggestion clearly.
+    const top = reordered[0];
+    if (isConfidentMatch(attempted, top)) {
+        process.stderr.write(`Did you mean \`shrk ${top.command}\`?\n`);
+        process.stderr.write(`  ${top.description}\n`);
+        // Second-tier suggestions only if they're also strong.
+        const others = reordered.slice(1, 3).filter((c) => isConfidentMatch(attempted, c));
+        if (others.length > 0) {
+            process.stderr.write('Other close matches:\n');
+            for (const c of others) {
+                process.stderr.write(`  shrk ${c.command} — ${c.description}\n`);
+            }
+        }
+        const footer = errorFooterFor('unknown-command', { task: attempted });
+        if (footer)
+            process.stderr.write(renderErrorFooter(footer));
+        return;
+    }
+    // Low-confidence: show up to 3 as "closest matches", honest about
+    // not knowing which is right.
+    process.stderr.write('Closest matches in the catalog:\n');
+    for (const c of reordered.slice(0, 3)) {
         process.stderr.write(`  shrk ${c.command} — ${c.description}\n`);
     }
-    // append the standardised next-command footer so the user
-    // always has a deterministic exit route.
+    process.stderr.write("If none of those look right, run `shrk help` or `shrk \"<task>\"` to route as a free-form task.\n");
     const footer = errorFooterFor('unknown-command', { task: attempted });
     if (footer)
         process.stderr.write(renderErrorFooter(footer));
 }
+/**
+ * Point fd 2 (stderr) at a log file so native-runtime teardown noise written
+ * during process exit lands in a file instead of the user's terminal. Returns
+ * silently on any failure (the worst case is the pre-existing noisy stderr).
+ *
+ * The log path can be overridden with `SHRK_NATIVE_TEARDOWN_LOG`; default is
+ * `<tmpdir>/shrk-native-teardown.log`. We append, with a timestamped header,
+ * so the trace is recoverable for debugging without ever touching the console.
+ */
+async function redirectStderrToTeardownLog() {
+    try {
+        const fs = await import('node:fs');
+        const os = await import('node:os');
+        const path = await import('node:path');
+        const logPath = process.env.SHRK_NATIVE_TEARDOWN_LOG?.trim() ||
+            path.join(os.tmpdir(), 'shrk-native-teardown.log');
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        // Close fd 2; the next open() reclaims the lowest free descriptor (2),
+        // so all subsequent stderr — including native C++ writes during
+        // `__cxa_finalize` — flows to the log file.
+        fs.closeSync(2);
+        const fd = fs.openSync(logPath, 'a');
+        if (fd !== 2) {
+            // Couldn't reclaim fd 2 — leave things as they are rather than risk
+            // writing the result to the wrong descriptor.
+            return;
+        }
+        fs.writeSync(2, `\n--- shrk native-runtime teardown @ ${new Date().toISOString()} ---\n`);
+    }
+    catch {
+        // Best-effort containment; never let log redirection break the exit.
+    }
+}
 // Entry point when invoked directly.
 //
 // Bun exposes `import.meta.main`; Node does not. When Node runs the
@@ -691,9 +895,119 @@ if (isMain ||
     entryPath.endsWith('shrk') ||
     entryPath.endsWith('shrk.js') ||
     entryPath.endsWith('shrk.cmd')) {
+    // Marks a real CLI invocation (vs. a command handler imported directly by a
+    // test). Commands that re-exec themselves in an isolated child gate on this
+    // so unit tests calling `run()` in-process never spawn a subprocess.
+    process.env.SHRK_CLI = '1';
+    loadDotenv(process.cwd());
     const argv = process.argv.slice(2);
-    runCli(argv).then((code) => process.exit(code), (err) => {
+    const cleanShutdown = async (code) => {
+        // Best-effort teardown of shared native runtimes. Without this,
+        // commands that loaded native libs (ONNX via embeddings; Metal
+        // via node-llama-cpp) abort during `process.exit` AFTER the
+        // work completed — the user sees their result then `zsh: abort`.
+        // Dynamic imports keep these off the hot path for commands that
+        // never touched them.
+        // Track whether any native runtime (ONNX via embeddings, Metal/ggml via
+        // node-llama-cpp) was actually loaded this run. If so, its static
+        // destructors can still abort with a backtrace during `exit()` below —
+        // and there is no JS hook in this Node version to skip libc++ finalizers.
+        // We contain that by redirecting fd 2 to a log file just before exit.
+        let nativeRuntimeLoaded = false;
+        try {
+            const mod = (await import('@shrkcrft/embeddings'));
+            if (typeof mod.disposeSemanticIndexPipeline === 'function') {
+                nativeRuntimeLoaded = (await mod.disposeSemanticIndexPipeline()) || nativeRuntimeLoaded;
+            }
+        }
+        catch {
+            // Best-effort; never block the exit on teardown failure.
+        }
+        try {
+            const mod = (await import('@shrkcrft/ai'));
+            if (typeof mod.disposeLlamaCppRuntime === 'function') {
+                nativeRuntimeLoaded = (await mod.disposeLlamaCppRuntime()) || nativeRuntimeLoaded;
+            }
+        }
+        catch {
+            // Best-effort.
+        }
+        // Flush stdio synchronously before bypassing C++ destructors.
+        // `_exit` skips all libc finalizers, which is exactly what we
+        // need (see below), but it also doesn't wait for buffered
+        // writes to drain. Two synchronous write callbacks force the
+        // current buffers through.
+        try {
+            await new Promise((resolve) => process.stdout.write('', () => resolve()));
+            await new Promise((resolve) => process.stderr.write('', () => resolve()));
+        }
+        catch {
+            // ignore flush failures
+        }
+        // When running as an isolated worker (e.g. the smart-context child), hand
+        // the real exit code back to the parent via a sentinel file. The native
+        // teardown abort below would otherwise clobber it with SIGABRT (134).
+        const exitCodeFile = process.env.SHRK_WORKER_EXITCODE_FILE;
+        if (exitCodeFile) {
+            try {
+                const fs = await import('node:fs');
+                fs.writeFileSync(exitCodeFile, String(code), 'utf8');
+            }
+            catch {
+                // best-effort; parent falls back to the child's signal/code.
+            }
+        }
+        // Contain native-runtime teardown noise. The ggml/ONNX destructors write a
+        // backtrace + `libc++abi: terminating … mutex lock failed` straight to fd 2
+        // during `exit()`, AFTER our real output is already on screen. That bypasses
+        // any JS stream wrapper, so the only reliable way to keep it off the user's
+        // terminal is to point fd 2 at a log file first: close(2) frees the lowest
+        // fd, and the next open() reclaims it. Gated on `nativeRuntimeLoaded` so
+        // ordinary commands keep their stderr untouched.
+        if (nativeRuntimeLoaded) {
+            await redirectStderrToTeardownLog();
+        }
+        // Prefer a low-level exit over `process.exit` on Node. Without
+        // this, libc++ static destructors run during `process.exit`, and
+        // native bindings still resident in memory abort with libc++abi
+        // errors AFTER the user's result has already printed:
+        //   - node-llama-cpp's libggml-metal hits `GGML_ASSERT([rsets->data
+        //     count] == 0)` in `ggml_metal_device_free` → `zsh: abort`.
+        //   - onnxruntime-node's worker pool aborts with
+        //     `libc++abi: mutex lock failed: Invalid argument` after a
+        //     successful `shrk smart-context embeddings-build`. NOTE:
+        //     `pipeline.dispose()` returns cleanly, but ONNX worker threads
+        //     are not actually joined — they continue running briefly and
+        //     hit the pthread mutex teardown race. There is no JS-layer
+        //     fix for this; upstream onnxruntime-node 1.21 has the bug.
+        //     The low-level exit at least suppresses the destructor pass
+        //     so the failure mode is "noisy stderr, exit code preserved"
+        //     rather than "destructor cascade".
+        //
+        // Node exposes the low-level exit under two names depending on the
+        // version:
+        //   - `process._exit`     — public alias (older Node; removed from
+        //                            the public surface on Node 22+).
+        //   - `process.reallyExit` — Node-internal name; still present on
+        //                            Node 22 even when `_exit` is undefined.
+        // Try both in order. Bun's process object doesn't expose either,
+        // but Bun also doesn't drive shutdown through libuv + libc++ static
+        // destructors the same way Node does, so the crash doesn't
+        // reproduce there. Fall back to `process.exit` when no low-level
+        // hook is available.
+        const proc = process;
+        const lowLevelExit = typeof proc._exit === 'function'
+            ? proc._exit
+            : typeof proc.reallyExit === 'function'
+                ? proc.reallyExit
+                : null;
+        if (lowLevelExit !== null) {
+            lowLevelExit(code);
+        }
+        process.exit(code);
+    };
+    runCli(argv).then((code) => cleanShutdown(code), (err) => {
         process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
-        process.exit(1);
+        return cleanShutdown(1);
     });
 }

package/dist/output/ccr-store-config.d.ts

@@ -0,0 +1,18 @@
+import { TtlFileCcrStore } from '@shrkcrft/compress';
+/**
+ * Upper bound on cached CCR originals under `.sharkcraft/ccr/`. The store evicts
+ * the oldest entries past this on every `put`, so the compress cache stays
+ * bounded instead of growing without limit (the old `FileCcrStore` had no cap).
+ * Count-based (not time-based) so a previously-cached key never silently
+ * expires out from under a `shrk expand` until it is genuinely the oldest and
+ * the cap is exceeded.
+ */
+export declare const CCR_MAX_ENTRIES = 1000;
+/** Absolute path to the per-project CCR cache directory (project-root-relative). */
+export declare function ccrDir(cwd: string): string;
+/**
+ * Open the bounded, cross-process CCR store the CLI write/read paths share.
+ * `ttlMs: 0` means no time expiry; `maxEntries` is the only bound.
+ */
+export declare function openCcrStore(cwd: string): TtlFileCcrStore;
+//# sourceMappingURL=ccr-store-config.d.ts.map

package/dist/output/ccr-store-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ccr-store-config.d.ts","sourceRoot":"","sources":["../../src/output/ccr-store-config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAmBrD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC,oFAAoF;AACpF,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAEzD"}

package/dist/output/ccr-store-config.js

@@ -0,0 +1,41 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { TtlFileCcrStore } from '@shrkcrft/compress';
+/**
+ * Walk up from `cwd` to the nearest ancestor containing a `.sharkcraft/` dir
+ * (the project root), so `compress` and `expand` share ONE cache per project —
+ * a `<<ccr:KEY>>` cached at the repo root stays recoverable from any subdir
+ * instead of being unrecoverable because `expand` looked in `<subdir>/.sharkcraft/ccr`.
+ * Falls back to `cwd` when no project root is found (a fresh repo).
+ */
+function ccrRoot(cwd) {
+    let dir = nodePath.resolve(cwd);
+    for (;;) {
+        if (existsSync(nodePath.join(dir, '.sharkcraft')))
+            return dir;
+        const parent = nodePath.dirname(dir);
+        if (parent === dir)
+            return cwd; // reached the filesystem root
+        dir = parent;
+    }
+}
+/**
+ * Upper bound on cached CCR originals under `.sharkcraft/ccr/`. The store evicts
+ * the oldest entries past this on every `put`, so the compress cache stays
+ * bounded instead of growing without limit (the old `FileCcrStore` had no cap).
+ * Count-based (not time-based) so a previously-cached key never silently
+ * expires out from under a `shrk expand` until it is genuinely the oldest and
+ * the cap is exceeded.
+ */
+export const CCR_MAX_ENTRIES = 1000;
+/** Absolute path to the per-project CCR cache directory (project-root-relative). */
+export function ccrDir(cwd) {
+    return nodePath.join(ccrRoot(cwd), '.sharkcraft', 'ccr');
+}
+/**
+ * Open the bounded, cross-process CCR store the CLI write/read paths share.
+ * `ttlMs: 0` means no time expiry; `maxEntries` is the only bound.
+ */
+export function openCcrStore(cwd) {
+    return new TtlFileCcrStore(ccrDir(cwd), { maxEntries: CCR_MAX_ENTRIES });
+}

package/dist/output/format-output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format-output.d.ts","sourceRoot":"","sources":["../../src/output/format-output.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,wBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAG3F;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7C;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GAAG,MAAM,CAWlE;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB"}
+{"version":3,"file":"format-output.d.ts","sourceRoot":"","sources":["../../src/output/format-output.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,wBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAG3F;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAO7C;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GAAG,MAAM,CAWlE;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB"}

package/dist/output/format-output.js

@@ -9,7 +9,12 @@ export function kv(key, value) {
     return `  ${key.padEnd(18)} ${v}`;
 }
 export function asJson(value) {
-    return JSON.stringify(value, null, 2);
+    // Minified by default: `--json` output is for machine / agent consumption, so
+    // we emit the smallest valid JSON (mirrors the MCP wire's default). The shape
+    // is unchanged — only whitespace is removed — so `JSON.parse` consumers are
+    // unaffected. Set SHRK_JSON_PRETTY=1 for human-readable 2-space indentation.
+    const pretty = process.env.SHRK_JSON_PRETTY === '1' || process.env.SHRK_JSON_PRETTY === 'true';
+    return pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value);
 }
 export function table(rows) {
     if (rows.length === 0)

package/dist/output/output-compression.d.ts

@@ -0,0 +1,15 @@
+import type { IGlobalCompressDirective } from '../command-registry.js';
+/**
+ * Implements the global `--compress` / `--ccr` flag: run a `shrk` command in a
+ * child process, capture its stdout, and emit a deterministically-compressed
+ * version (with the original cached for `shrk expand`). The command's own
+ * stderr is forwarded verbatim and its exit code is preserved.
+ *
+ * A SUBPROCESS (not in-process `process.stdout` capture) on purpose: some
+ * commands call `process.exit`, which would discard a buffered in-process
+ * capture mid-write; re-running the command isolates that and still yields the
+ * full output + real exit status. `childArgv` has already had the compress
+ * flags stripped, so the child never recurses.
+ */
+export declare function runCommandWithCompression(childArgv: readonly string[], directive: IGlobalCompressDirective, cwd: string): number;
+//# sourceMappingURL=output-compression.d.ts.map

package/dist/output/output-compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-compression.d.ts","sourceRoot":"","sources":["../../src/output/output-compression.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAQvE;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,SAAS,EAAE,wBAAwB,EACnC,GAAG,EAAE,MAAM,GACV,MAAM,CAgDR"}