@compaction/cli 0.2.0 → 0.3.1

package/dist/cli/commands/dev.js

@@ -0,0 +1,131 @@
+/**
+ * Gateway-native "run a workflow through the gateway" runner (PUBLIC CLI). Charter run-17.1 / run-18A.
+ *
+ * The public gateway-native entry point is `compaction gateway run -- <command>`. `compaction dev -- …`
+ * remains as a hidden compatibility alias (same behavior). Both call `runThroughGateway`.
+ *
+ * Runs any command with its OpenAI base URL pointed at the local Compaction Gateway, so an
+ * OpenAI-compatible app/SDK routes through Compaction with NO manual baseURL copy-paste:
+ *   compaction gateway run -- npm run dev
+ *   compaction gateway run -- node app.js
+ *
+ * Behavior: start (or REUSE) the local gateway → inject the gateway endpoint env into the child (never a
+ * key) → run the child with stdio inherited (stdout/stderr/stdin pass through UNCHANGED) → exit with the
+ * child's exit code → print a content-free "traffic observed" summary (receipts recorded during this run).
+ * It NEVER reads/stores a provider key, NEVER mutates files, and NEVER mutates requests/responses.
+ */
+import { spawn } from "node:child_process";
+import { runGatewayStart, parseListen } from "./gateway.js";
+import { getGatewayStatus, readReceipts } from "../../core/gateway/status.js";
+import { summarizeCacheProof } from "../../core/gateway/cache-proof.js";
+import { formatFreshBilledInputReduction } from "../../core/gateway/receipt.js";
+/** The OpenAI-compatible base-url env vars the SDKs read. We set the base only — never a key. */
+function injectionEnv(base) {
+    const v1 = `${base}/v1`;
+    return { OPENAI_BASE_URL: v1, OPENAI_API_BASE: v1 };
+}
+/** True when SOME provider key is present in the environment (we never read its value). */
+function hasProviderKey(env) {
+    return Boolean((env.OPENAI_API_KEY && env.OPENAI_API_KEY.trim()) || (env.OPENAI_KEY && env.OPENAI_KEY.trim()));
+}
+/**
+ * Run `command` through the local Compaction Gateway. Shared by `gateway run` (the public gateway-native
+ * form) and the hidden `dev` compatibility alias — `label` only changes the message prefix + usage hint.
+ * Calls `process.exit(code)` with the child's exit code (so it is a terminal action).
+ */
+export async function runThroughGateway(command, options, label = "compaction gateway run") {
+    const parts = command ?? [];
+    if (parts.length === 0) {
+        console.error(`error: no command given. Usage: ${label} -- <command>   (e.g. ${label} -- npm run dev)`);
+        process.exitCode = 1;
+        return;
+    }
+    const cwd = process.cwd();
+    const provider = options.provider ?? "openai";
+    const upstream = options.upstream ?? "https://api.openai.com/v1";
+    // Reuse a gateway already running in this project, else start our own (ephemeral, quiet).
+    const status = await getGatewayStatus(cwd);
+    let base;
+    let ownGateway = null;
+    if (status.running && status.base) {
+        base = status.base;
+        console.error(`${label}: reusing the running gateway at ${base}`);
+        // Honest note: this runner itself always starts in RECORD; if it reuses a gateway the user explicitly
+        // started in a mutating mode, say so plainly (it does not silently change that mode).
+        if (status.mode && status.mode !== "record") {
+            console.error(`${label}: note — the reused gateway is running in '${status.mode}' mode (you started it explicitly); this is not changing that.`);
+        }
+    }
+    else {
+        const port = options.listen ? parseListen(options.listen).port : 0; // 0 → ephemeral (no port conflicts)
+        try {
+            const g = await runGatewayStart({ provider, upstream, mode: "record", host: "127.0.0.1", port, cwd, installSignals: false, log: () => { } });
+            base = g.base;
+            ownGateway = g;
+            console.error(`${label}: started a local gateway at ${base} (record mode; byte-safe; content-free receipts)`);
+        }
+        catch (err) {
+            console.error(`error: could not start a local gateway — ${err.message}`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const childEnv = { ...process.env, ...injectionEnv(base) };
+    console.error(`${label}: routing → OPENAI_BASE_URL=${base}/v1  (your provider key stays on the child; the gateway never stores it)`);
+    if (!hasProviderKey(process.env)) {
+        console.error(`${label}: Gateway is ready, but the child process still needs its provider API key (e.g. OPENAI_API_KEY). Compaction never injects or stores keys.`);
+    }
+    // Snapshot receipts so we can report ONLY the traffic observed during this run (content-free).
+    const before = new Set(readReceipts(cwd).map((r) => r.receipt_id));
+    const child = spawn(parts[0], parts.slice(1), { stdio: "inherit", env: childEnv, cwd });
+    const code = await new Promise((resolve) => {
+        child.on("exit", (c, signal) => resolve(typeof c === "number" ? c : signal ? 1 : 0));
+        child.on("error", (err) => {
+            console.error(`${label}: failed to run '${parts[0]}' — ${err.message}`);
+            resolve(127);
+        });
+    });
+    if (ownGateway) {
+        try {
+            await ownGateway.close();
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    // Content-free traffic summary: only the receipts recorded during this run.
+    const observed = readReceipts(cwd).filter((r) => !before.has(r.receipt_id));
+    console.error("");
+    if (observed.length > 0) {
+        const summary = summarizeCacheProof(observed);
+        console.error(`${label}: ✓ traffic observed through Compaction — ${observed.length} request(s) this run.`);
+        console.error(`  best provider-backed fresh/billed input reduction:  ${formatFreshBilledInputReduction(summary.bestReduction)}`);
+        console.error("  run 'compaction gateway status' for the full content-free rollup.");
+    }
+    else {
+        console.error(`${label}: ○ no requests were observed through Compaction this run.`);
+        console.error("  If your app has its own OpenAI base URL configured, it may have bypassed OPENAI_BASE_URL.");
+        console.error("  Point your client at the injected base URL, or use 'compaction gateway configure' to set it.");
+    }
+    process.exit(code);
+}
+/**
+ * Register the hidden `dev` compatibility alias. The PUBLIC gateway-native form is `gateway run`
+ * (registered in gateway.ts); `dev` is kept for backward compatibility and hidden from top-level help.
+ */
+export function registerDevCommand(program) {
+    program
+        .command("dev")
+        .description("Compatibility alias for 'compaction gateway run -- <command>'. Runs a command with its OpenAI base " +
+        "URL pointed at the local Compaction Gateway (starts/reuses the gateway, injects the endpoint — never " +
+        "a key, streams output unchanged, preserves the exit code, prints a content-free traffic summary).")
+        .option("--provider <name>", "Provider (OpenAI-compatible only).", "openai")
+        .option("--upstream <url>", "Upstream provider base URL.", "https://api.openai.com/v1")
+        .option("--listen <url>", "Local listen address when starting a gateway (default: an ephemeral local port).")
+        .argument("[command...]", "The command to run through the gateway (after --), e.g. -- npm run dev")
+        .allowUnknownOption(true)
+        .action(async (command, options) => {
+        await runThroughGateway(command, options, "compaction dev");
+    });
+}
+//# sourceMappingURL=dev.js.map

package/dist/cli/commands/gateway.d.ts

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { type GatewayServerMode } from "../../core/gateway/server.js";
+/** Parse `--listen http://127.0.0.1:8787` (or `127.0.0.1:8787`) into host + port. */
+export declare function parseListen(listen: string): {
+    host: string;
+    port: number;
+};
+export interface GatewayStartConfig {
+    provider: string;
+    upstream: string;
+    mode: GatewayServerMode;
+    /** Deterministic apply policy (required for apply/dry-run). Only `deterministic-dedupe` is implemented. */
+    policy?: string;
+    host: string;
+    port: number;
+    cwd?: string;
+    log?: (line: string) => void;
+    /** Install SIGINT/SIGTERM handlers that close the server + remove the pidfile (default true). */
+    installSignals?: boolean;
+}
+export interface RunningGateway {
+    base: string;
+    close: () => Promise<void>;
+}
+/**
+ * Start the gateway from a validated config: bind the server, write the content-free pidfile (so
+ * `status`/`stop` work), print the honest banner, and install shutdown handlers that remove the pidfile.
+ * Reused by both `gateway start` and the guided onboarding. Throws on bind failure (the caller reports it).
+ */
+export declare function runGatewayStart(config: GatewayStartConfig): Promise<RunningGateway>;
+export declare function registerGatewayCommand(program: Command): void;

package/dist/cli/commands/gateway.js

@@ -0,0 +1,312 @@
+/**
+ * `compaction gateway start|status|stop` — the local Compaction Gateway (PUBLIC CLI). Charter run-15
+ * (record mode) + run-17 (lifecycle + guided onboarding).
+ *
+ * RECORD MODE only: a byte-safe, OpenAI-compatible local reverse proxy. Point your OpenAI client's base
+ * URL at the gateway; it forwards the request + response to the real provider BYTE-FOR-BYTE and records
+ * ONE content-free token/cache/cost receipt per call. No mutation, no cache optimization, no apply, no
+ * LCM. The client's API key rides straight through to the provider and is NEVER read, stored, or logged.
+ *
+ * `runGatewayStart` is exported so the guided onboarding TUI (`GatewayTui` → `init`) can start the same
+ * gateway with a config picked interactively — no duplicate server, no new behavior.
+ */
+import { URL } from "node:url";
+import path from "node:path";
+import { writeFileSync } from "node:fs";
+import { startGatewayServer } from "../../core/gateway/server.js";
+import { DEFAULT_GATEWAY_RECEIPTS_DIR, GATEWAY_RECEIPTS_FILE, formatFreshBilledInputReduction } from "../../core/gateway/receipt.js";
+import { writeGatewayPid, removeGatewayPid, readGatewayPid, getGatewayStatus, isProcessAlive } from "../../core/gateway/status.js";
+import { planGatewayConfigure, applyGatewayConfigure, formatConfigurePlan } from "../../core/gateway/configure.js";
+import { DEDUPE_POLICY } from "../../core/gateway/apply-policy.js";
+import { GATEWAY_RECOVERY_DIR, readRecovery } from "../../core/gateway/recovery.js";
+import { runThroughGateway } from "./dev.js";
+/** Parse `--listen http://127.0.0.1:8787` (or `127.0.0.1:8787`) into host + port. */
+export function parseListen(listen) {
+    const raw = listen.includes("://") ? listen : `http://${listen}`;
+    const u = new URL(raw);
+    const port = u.port ? Number.parseInt(u.port, 10) : 8787;
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new Error(`invalid --listen port in '${listen}'`);
+    }
+    return { host: u.hostname || "127.0.0.1", port };
+}
+/**
+ * Start the gateway from a validated config: bind the server, write the content-free pidfile (so
+ * `status`/`stop` work), print the honest banner, and install shutdown handlers that remove the pidfile.
+ * Reused by both `gateway start` and the guided onboarding. Throws on bind failure (the caller reports it).
+ */
+export async function runGatewayStart(config) {
+    if (config.mode !== "record" && config.mode !== "apply" && config.mode !== "dry-run") {
+        throw new Error(`gateway mode '${config.mode}' is not implemented (record | apply | dry-run)`);
+    }
+    const mutating = config.mode === "apply" || config.mode === "dry-run";
+    if (mutating && config.policy !== DEDUPE_POLICY) {
+        throw new Error(`gateway --mode ${config.mode} requires --policy ${DEDUPE_POLICY} (the only deterministic policy implemented)`);
+    }
+    const cwd = config.cwd ?? process.cwd();
+    const log = config.log ?? ((line) => console.log(line));
+    const started = await startGatewayServer({
+        provider: config.provider,
+        upstream: config.upstream,
+        mode: config.mode,
+        ...(config.policy ? { policy: config.policy } : {}),
+        cwd,
+        log,
+        host: config.host,
+        port: config.port
+    });
+    const base = `http://${started.address.host}:${started.address.port}`;
+    writeGatewayPid({
+        pid: process.pid,
+        host: started.address.host,
+        port: started.address.port,
+        upstream: config.upstream,
+        provider: config.provider,
+        mode: config.mode,
+        startedAt: new Date().toISOString()
+    }, cwd);
+    const receiptsPath = path.join(cwd, DEFAULT_GATEWAY_RECEIPTS_DIR, GATEWAY_RECEIPTS_FILE);
+    if (config.mode === "record") {
+        log("compaction gateway — RECORD mode (byte-safe; no mutation; content-free receipts)");
+    }
+    else if (config.mode === "dry-run") {
+        log(`compaction gateway — DRY-RUN mode (policy ${config.policy}; computes a candidate but forwards the ORIGINAL request unchanged)`);
+    }
+    else {
+        log(`compaction gateway — APPLY mode · EXPERIMENTAL (policy ${config.policy}; DETERMINISTIC only)`);
+        log("  Apply changes model-visible input for KNOWN-SAFE shapes only; the original is retained locally;");
+        log("  unknown/complex shapes FAIL CLOSED (forwarded unchanged). System/developer instructions & tool schemas are never touched.");
+    }
+    log(`  provider:  ${config.provider}  →  upstream ${config.upstream}`);
+    log(`  receipts:  ${receiptsPath}   (local-only, gitignored; token/cache counts only — no prompt/response content)`);
+    if (mutating)
+        log(`  recovery:  ${path.join(cwd, GATEWAY_RECOVERY_DIR)}   (local-only; the ORIGINAL request body when apply changes it — recover with 'compaction gateway recover <id>')`);
+    log("");
+    log(`Gateway running at ${base}`);
+    log("");
+    log("Run one command through Compaction:");
+    log("  compaction gateway run -- npm run dev");
+    log("");
+    log("Inspect traffic:");
+    log("  compaction gateway status");
+    log("");
+    log("If manual setup is needed:");
+    log(`  compaction gateway configure    (or point your OpenAI client at  baseURL = ${base}/v1  — keep your key on the client; the gateway never stores it)`);
+    log("");
+    log("  Stop from another terminal:  compaction gateway stop   ·   or press Ctrl-C here.");
+    const close = async () => {
+        removeGatewayPid(cwd);
+        await started.close();
+    };
+    if (config.installSignals !== false) {
+        const shutdown = async () => {
+            await close();
+            process.exit(0);
+        };
+        process.on("SIGINT", () => void shutdown());
+        process.on("SIGTERM", () => void shutdown());
+    }
+    return { base, close };
+}
+export function registerGatewayCommand(program) {
+    const gateway = program
+        .command("gateway")
+        .description("Local Compaction Gateway — a byte-safe, OpenAI-compatible reverse proxy that records a content-free " +
+        "token/cache/cost receipt per call. Default RECORD mode (no mutation); EXPERIMENTAL deterministic " +
+        "apply/dry-run modes are explicit opt-in (no cache-opt, no LCM, no semantic compaction).");
+    gateway
+        .command("start")
+        .description("Start the local gateway. Point your OpenAI client's base URL at --listen. RECORD forwards byte-for-byte; APPLY (experimental, explicit) deterministically dedupes known-safe shapes and retains the original locally.")
+        .option("--provider <name>", "Provider (OpenAI-compatible only).", "openai")
+        .option("--upstream <url>", "Upstream provider base URL (the request path is forwarded to its origin).", "https://api.openai.com/v1")
+        .option("--listen <url>", "Local address to listen on (e.g. http://127.0.0.1:8787).", "http://127.0.0.1:8787")
+        .option("--mode <mode>", "Gateway mode: record (default, byte-safe) | apply (experimental, deterministic) | dry-run (preview, forwards original).", "record")
+        .option("--policy <name>", `Deterministic apply policy (required for apply/dry-run). Only '${DEDUPE_POLICY}' is implemented.`)
+        .option("--approval <mode>", "Apply approval model (informational in run-17.2: starting apply mode IS the explicit approval; per-request interactive approval is deferred).", "ask")
+        .action(async (options) => {
+        const mode = (options.mode ?? "record");
+        if (mode !== "record" && mode !== "apply" && mode !== "dry-run") {
+            console.error(`error: gateway mode '${mode}' is not implemented (record | apply | dry-run).`);
+            process.exitCode = 1;
+            return;
+        }
+        if ((mode === "apply" || mode === "dry-run") && options.policy !== DEDUPE_POLICY) {
+            console.error(`error: --mode ${mode} requires --policy ${DEDUPE_POLICY} (the only deterministic policy implemented). ` +
+                `Apply is deterministic-only — no semantic compaction, no LCM.`);
+            process.exitCode = 1;
+            return;
+        }
+        const provider = options.provider ?? "openai";
+        const upstream = options.upstream ?? "https://api.openai.com/v1";
+        try {
+            new URL(upstream);
+        }
+        catch {
+            console.error(`error: --upstream '${upstream}' is not a valid URL.`);
+            process.exitCode = 1;
+            return;
+        }
+        let listen;
+        try {
+            listen = parseListen(options.listen ?? "http://127.0.0.1:8787");
+        }
+        catch (err) {
+            console.error(`error: ${err.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            await runGatewayStart({ provider, upstream, mode, ...(options.policy ? { policy: options.policy } : {}), host: listen.host, port: listen.port });
+        }
+        catch (err) {
+            console.error(`error: could not start the gateway on ${listen.host}:${listen.port} — ${err.message}`);
+            process.exitCode = 1;
+        }
+    });
+    gateway
+        .command("status")
+        .description("Show whether the local gateway is running + a content-free rollup of its receipts (token/cache; no content).")
+        .option("--json", "Print the content-free status as JSON.")
+        .action(async (options) => {
+        const status = await getGatewayStatus(process.cwd());
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        console.log("compaction gateway status");
+        if (status.running) {
+            console.log(`  gateway running:      yes  ${status.base ?? ""}  (pid ${status.pid})`);
+            console.log(`  provider / mode:      ${status.provider} / ${status.mode}`);
+            console.log(`  listen URL:           ${status.base ?? "(unknown)"}`);
+        }
+        else if (status.pid) {
+            console.log(`  gateway running:      no  (stale pidfile for pid ${status.pid} — run 'compaction gateway stop' to clear it)`);
+        }
+        else {
+            console.log("  gateway running:      no  (start it with 'compaction gateway start', or 'compaction' → Gateway setup)");
+        }
+        console.log(`  requests observed:    ${status.receiptsCount}  (local-only, content-free)`);
+        console.log(`  last request:         ${status.lastRequestAt ?? "none observed yet"}`);
+        console.log(`  cached input seen:    ${status.receiptsCount > 0 ? (status.cachedObserved ? "yes" : "no") : "unknown (no requests yet)"}`);
+        if (status.receiptsCount > 0) {
+            console.log(`  best fresh/billed input reduction:  ${formatFreshBilledInputReduction(status.summary.bestReduction)}`);
+            console.log(`  ${status.summary.modelVisibleBytesUnchanged ? "model-visible bytes unchanged" : "model-visible bytes: mixed — check receipts"}`);
+        }
+    });
+    gateway
+        .command("run")
+        .description("Run a command through the local Compaction Gateway. Usage: compaction gateway run -- <command>. Starts/reuses the gateway, injects the endpoint into the child (never a key), streams its output unchanged, preserves its exit code, and prints a content-free traffic summary.")
+        .option("--provider <name>", "Provider (OpenAI-compatible only).", "openai")
+        .option("--upstream <url>", "Upstream provider base URL.", "https://api.openai.com/v1")
+        .option("--listen <url>", "Local listen address when starting a gateway (default: an ephemeral local port).")
+        .argument("[command...]", "The command to run through the gateway (after --), e.g. -- npm run dev")
+        .allowUnknownOption(true)
+        .action(async (command, options) => {
+        await runThroughGateway(command, options, "compaction gateway run");
+    });
+    gateway
+        .command("activate")
+        .description("Print shell export lines that point THIS shell's OpenAI base URL at the local gateway. Use:  eval \"$(compaction gateway activate)\". It only PRINTS — it never edits files or mutates your shell, and it never attaches to a running process.")
+        .option("--listen <url>", "Gateway listen address to point at (default: the running gateway, else http://127.0.0.1:8787).")
+        .action(async (options) => {
+        const status = await getGatewayStatus(process.cwd());
+        let base;
+        if (options.listen) {
+            const l = parseListen(options.listen);
+            base = `http://${l.host}:${l.port}`;
+        }
+        else if (status.running && status.base) {
+            base = status.base;
+        }
+        else {
+            base = "http://127.0.0.1:8787";
+        }
+        const v1 = `${base}/v1`;
+        // Guidance to STDERR (not captured by eval); the exports go to STDOUT (captured by eval).
+        console.error('# compaction gateway activate — apply to this shell with:  eval "$(compaction gateway activate)"');
+        if (!(status.running && status.base) && !options.listen) {
+            console.error("# note: no running gateway detected; start one with 'compaction gateway start' (these exports point at the default local address).");
+        }
+        console.error("# your provider API key stays in your shell — the gateway never reads or stores it.");
+        console.log(`export OPENAI_BASE_URL=${v1}`);
+        console.log(`export OPENAI_API_BASE=${v1}`);
+    });
+    gateway
+        .command("configure")
+        .description("Propose pointing this project's OpenAI base URL at the local gateway (approval-gated: shows a diff; writes nothing without --apply; backs up first; never overwrites an existing base URL without --force).")
+        .option("--listen <url>", "Gateway listen address to route to (default: http://127.0.0.1:8787).", "http://127.0.0.1:8787")
+        .option("--apply", "Actually write the change (creates a .bak backup first).")
+        .option("--force", "Overwrite an existing provider base URL (only with --apply).")
+        .action((options) => {
+        let listen;
+        try {
+            listen = parseListen(options.listen ?? "http://127.0.0.1:8787");
+        }
+        catch (err) {
+            console.error(`error: ${err.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        const baseUrl = `http://${listen.host}:${listen.port}/v1`;
+        const cwd = process.cwd();
+        const plan = planGatewayConfigure(cwd, baseUrl);
+        for (const line of formatConfigurePlan(plan))
+            console.log(line);
+        if (!options.apply)
+            return;
+        const result = applyGatewayConfigure(cwd, plan, options.force ?? false);
+        console.log("");
+        if (result.wrote) {
+            console.log(`compaction gateway configure: wrote ${result.targetFile}${result.backupFile ? ` (backup: ${result.backupFile})` : ""}.`);
+            console.log("  restart your app so it picks up the new base URL, or run:  compaction gateway run -- <command>");
+        }
+        else {
+            console.log(`compaction gateway configure: not written — ${result.reason}`);
+            process.exitCode = 1;
+        }
+    });
+    gateway
+        .command("recover")
+        .description("Recover the ORIGINAL request body that apply mode changed (retained locally under .compaction/gateway/recovery). Prints to stdout or writes to --out.")
+        .argument("<recovery_id>", "The recovery_id shown on the apply receipt.")
+        .option("--out <file>", "Write the original body to this file instead of stdout.")
+        .action((recoveryId, options) => {
+        const rec = readRecovery(process.cwd(), recoveryId);
+        if (!rec) {
+            console.error(`compaction gateway recover: no retained original found for id '${recoveryId}' under ${GATEWAY_RECOVERY_DIR}.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (options.out) {
+            writeFileSync(options.out, rec.original_body, "utf8");
+            console.error(`compaction gateway recover: wrote the original request body (${rec.endpoint}, policy ${rec.policy}, captured ${rec.captured_at}) to ${options.out}.`);
+            return;
+        }
+        // The original body IS request content — it prints to stdout only on explicit recovery, never stored in a receipt.
+        process.stdout.write(rec.original_body.endsWith("\n") ? rec.original_body : `${rec.original_body}\n`);
+    });
+    gateway
+        .command("stop")
+        .description("Stop a running local gateway (started in another terminal) via its pidfile.")
+        .action(() => {
+        const rec = readGatewayPid(process.cwd());
+        if (!rec) {
+            console.log("compaction gateway stop: no gateway pidfile found — nothing to stop.");
+            return;
+        }
+        if (!isProcessAlive(rec.pid)) {
+            removeGatewayPid(process.cwd());
+            console.log(`compaction gateway stop: pid ${rec.pid} is not running — cleared the stale pidfile.`);
+            return;
+        }
+        try {
+            process.kill(rec.pid, "SIGTERM");
+            console.log(`compaction gateway stop: sent SIGTERM to pid ${rec.pid} (${rec.host}:${rec.port}). It removes its own pidfile on exit.`);
+        }
+        catch (err) {
+            console.error(`compaction gateway stop: could not signal pid ${rec.pid} — ${err.message}`);
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=gateway.js.map

package/dist/cli/commands/hooks.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { type HookUsageAggregate } from "../../core/hook-usage-aggregate.js";
+export declare function registerHooksCommand(program: Command): void;
+/** Render the content-free source-status aggregate as a readable block (provider-reported vs unavailable). */
+export declare function printHookUsageAggregate(aggregate: HookUsageAggregate): string;