@compaction/cli 0.1.0

package/dist/cli/commands/apply.js

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import chalk from "chalk";
+// PUBLIC constant from the policy-types module (Phase 1a) — no engine runtime edge.
+import { COMPACTION_POLICY_NAME } from "../../core/policy-types.js";
+import { parseTraceFile } from "../../core/trace-parser.js";
+import { runEngineCommand } from "../engine-degrade.js";
+async function readRecommendationMode(traceId, isRecommendationMode) {
+    const recommendationPath = `.compaction/recommendations/${traceId}/recommendation.json`;
+    try {
+        const recommendation = JSON.parse(await readFile(recommendationPath, "utf8"));
+        return typeof recommendation.recommended_mode === "string" && isRecommendationMode(recommendation.recommended_mode)
+            ? recommendation.recommended_mode
+            : undefined;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function registerApplyCommand(program) {
+    program
+        .command("apply")
+        .argument("<trace-file>", "Path to a local agent trace JSON file")
+        .requiredOption("--policy <name>", "Reviewed deterministic local policy to apply")
+        .option("--require-safety-pass", "Refuse apply unless the deterministic local safety report passes")
+        .description("Apply a reviewed local deterministic compaction policy and write apply artifacts.")
+        .action(async (traceFile, options) => {
+        await runEngineCommand(async () => {
+            // Lazy-load the proprietary engine: present in-repo/API, excluded from the public package.
+            // When absent, runEngineCommand prints the boundary message and exits cleanly (no stack trace).
+            const { isRecommendationMode } = await import("../../engine/recommendation.js");
+            const { writeApplyArtifacts } = await import("../../engine/apply-mode.js");
+            const trace = await parseTraceFile(traceFile);
+            const recommendationMode = await readRecommendationMode(trace.id, isRecommendationMode);
+            const artifacts = await writeApplyArtifacts({
+                trace,
+                policy: {
+                    name: options.policy,
+                    isLocal: options.policy === COMPACTION_POLICY_NAME,
+                    isDeterministic: options.policy === COMPACTION_POLICY_NAME
+                },
+                requireSafetyPass: options.requireSafetyPass === true,
+                generatedAt: trace.generatedAt,
+                recommendationMode
+            });
+            console.log(chalk.cyan("compaction apply"));
+            console.log(`Trace id: ${artifacts.report.trace_id}`);
+            console.log(`Policy name: ${artifacts.report.policy_name}`);
+            console.log(`Safety status: ${artifacts.report.safety_status}`);
+            console.log(`Risk level: ${artifacts.report.risk_level}`);
+            console.log(`Applied: ${artifacts.report.applied}`);
+            console.log(`Refusal reason: ${artifacts.report.refusal_reason ?? "None"}`);
+            console.log(`Required next step: ${artifacts.report.required_next_step}`);
+            console.log(chalk.green(`Wrote ${artifacts.paths.appliedTracePath}`));
+            console.log(chalk.green(`Wrote ${artifacts.paths.applyReportJsonPath}`));
+            console.log(chalk.green(`Wrote ${artifacts.paths.applyReportMarkdownPath}`));
+            if (!artifacts.report.applied) {
+                process.exitCode = 1;
+            }
+        });
+    });
+}
+//# sourceMappingURL=apply.js.map

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

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerApproveCommand(program: Command): void;

package/dist/cli/commands/approve.js

@@ -0,0 +1,55 @@
+import chalk from "chalk";
+import { runEngineCommand } from "../engine-degrade.js";
+export function registerApproveCommand(program) {
+    program
+        .command("approve")
+        .description("Approve and locally apply a reviewed optimization recommendation to a captured trace copy.")
+        .argument("<optimization-id>", "Optimization ID produced by compaction optimize openai-agents")
+        .option("--require-safety-pass", "Refuse approval unless safety status is pass")
+        .option("--approve-skill-injection-policy", "EXPLICITLY also authorize the approval-required repeated_skill_injection_to_state_capsule policy to compact byte-identical same-skill role:user skill injections. Approval-gated; default off; no auto-apply.")
+        .option("--pre-apply", "READ-ONLY pre-apply view: show before/after input tokens, estimated cost, recoverability, evidence tier, and approval_readiness (not_ready/conditional/ready) WITHOUT applying anything or emitting an approved trace. No auto-apply.")
+        .action(async (optimizationId, options) => {
+        await runEngineCommand(async () => {
+            // Lazy-load the proprietary engine: present in-repo/API, excluded from the public package.
+            // When absent, runEngineCommand prints the boundary message and exits cleanly (no stack trace).
+            const { approveOptimization } = await import("../../engine/optimization-approval.js");
+            const { buildPreApplyApprovalView } = await import("../../engine/pre-apply-approval-view.js");
+            if (options.preApply) {
+                console.log(chalk.cyan("compaction approve --pre-apply"));
+                console.log("Read-only pre-apply view. NOTHING is applied; no approved trace is emitted. No provider APIs, live workflow mutation, production proxying, auto mode, model routing, or hosted dashboard is performed.");
+                const view = await buildPreApplyApprovalView({
+                    optimizationId,
+                    requireSafetyPass: Boolean(options.requireSafetyPass),
+                    includeSkillInjectionPolicy: Boolean(options.approveSkillInjectionPolicy)
+                });
+                console.log(view.terminalSummary);
+                console.log(chalk.green(`Wrote ${view.paths.preApplyReportJsonPath}`));
+                console.log(chalk.green(`Wrote ${view.paths.preApplyReportMarkdownPath}`));
+                console.log(chalk.green(`Evidence directory: ${view.outputDirectory}`));
+                // Read-only: never apply. Exit non-zero only when apply would be blocked, so scripts can gate.
+                if (view.report.approval_readiness === "not_ready") {
+                    process.exitCode = 1;
+                }
+                return;
+            }
+            console.log(chalk.cyan("compaction approve"));
+            console.log("Running explicit local approval only. No provider APIs, live workflow mutation, production proxying, auto mode, model routing, or hosted dashboard is performed.");
+            const artifacts = await approveOptimization({
+                optimizationId,
+                requireSafetyPass: Boolean(options.requireSafetyPass),
+                approveSkillInjectionPolicy: Boolean(options.approveSkillInjectionPolicy)
+            });
+            console.log(artifacts.terminalSummary);
+            console.log(chalk.green(`Wrote ${artifacts.paths.approvalReportJsonPath}`));
+            console.log(chalk.green(`Wrote ${artifacts.paths.approvalReportMarkdownPath}`));
+            if (artifacts.paths.approvedTracePath) {
+                console.log(chalk.green(`Wrote ${artifacts.paths.approvedTracePath}`));
+            }
+            console.log(chalk.green(`Evidence directory: ${artifacts.outputDirectory}`));
+            if (!artifacts.report.approved) {
+                process.exitCode = 1;
+            }
+        });
+    });
+}
+//# sourceMappingURL=approve.js.map

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

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerAuditCommand(program: Command): void;

package/dist/cli/commands/audit.js

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+// FREE: the default `audit` package path uses only public core (engine refs in audit-report are
+// type-only). The `--traces` / `--adapter` pilot paths run the proprietary engine and are lazy-loaded
+// in their branches below, degrading honestly when the engine build is excluded from the package.
+import { writeAuditArtifacts } from "../../core/audit-report.js";
+import { runEngineCommand } from "../engine-degrade.js";
+function formatCurrency(value) {
+    return `$${value.toFixed(6)}`;
+}
+const supportedPilotSources = ["agent-trace", "messages", "unknown"];
+function parsePilotSource(source) {
+    if (supportedPilotSources.includes(source)) {
+        return source;
+    }
+    throw new Error(`Unsupported source "${source}". Supported sources: ${supportedPilotSources.join(", ")}.`);
+}
+export function registerAuditCommand(program) {
+    program
+        .command("audit")
+        .description("Package local compaction artifacts or run a local trace audit pilot folder.")
+        .option("--traces <dir>", "Directory of local trace files to audit")
+        .option("--adapter <adapter-id>", "Adapter registry id for the adapter audit workflow")
+        .option("--source <source>", "Pilot input source: agent-trace, messages, or unknown", "unknown")
+        .action(async (options) => {
+        if (options.traces && options.adapter) {
+            await runEngineCommand(async () => {
+                // Engine-backed adapter audit (compaction + recommendation over each trace). Lazy-load;
+                // degrades honestly when the engine build is excluded from the package.
+                const { runAdapterAudit } = await import("../../core/adapter-audit.js");
+                const result = await runAdapterAudit(options.traces, options.adapter);
+                console.log(chalk.cyan("compaction audit"));
+                console.log(result.consoleSummary);
+                console.log(chalk.green(`Wrote ${result.paths.adapterAuditSummaryJsonPath}`));
+                console.log(chalk.green(`Wrote ${result.paths.adapterAuditSummaryMarkdownPath}`));
+            });
+            return;
+        }
+        if (options.traces) {
+            await runEngineCommand(async () => {
+                // Engine-backed local trace audit pilot (compaction + recommendation over a folder of traces).
+                // Lazy-load; degrades honestly when the engine build is excluded from the package.
+                const { runLocalTraceAuditPilot } = await import("../../core/pilot-audit.js");
+                const result = await runLocalTraceAuditPilot(options.traces, parsePilotSource(options.source ?? "unknown"));
+                console.log(chalk.cyan("compaction audit"));
+                console.log(result.consoleSummary);
+                console.log(chalk.green(`Wrote ${result.paths.pilotSummaryJsonPath}`));
+                console.log(chalk.green(`Wrote ${result.paths.pilotSummaryMarkdownPath}`));
+            });
+            return;
+        }
+        const artifacts = await writeAuditArtifacts();
+        console.log(chalk.cyan("compaction audit"));
+        console.log(`Audit id: ${artifacts.audit.audit_id}`);
+        console.log(`Runs summarized: ${artifacts.audit.total_runs}`);
+        console.log(`Savings: ${artifacts.audit.total_tokens_saved} input tokens saved, ${formatCurrency(artifacts.audit.total_saving_per_run)} estimated saving per run, summed over ${artifacts.audit.total_runs} recorded run${artifacts.audit.total_runs === 1 ? "" : "s"}.`);
+        console.log(`Recommendation artifacts: ${artifacts.audit.recommendation_summary.total_recommendations}`);
+        console.log(`Apply artifacts: ${artifacts.audit.apply_summary?.total_apply_reports ?? 0}`);
+        console.log("Local-only audit package; no provider calls or hosted services are used.");
+        console.log(chalk.green(`Wrote ${artifacts.paths.auditJsonPath}`));
+        console.log(chalk.green(`Wrote ${artifacts.paths.auditMarkdownPath}`));
+    });
+}
+//# sourceMappingURL=audit.js.map

package/dist/cli/commands/billing-delta.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerBillingDeltaCommand(program: Command): void;

package/dist/cli/commands/billing-delta.js

@@ -0,0 +1,246 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { writeJsonArtifact, writeTextArtifact } from "../../core/artifact-writer.js";
+import { addRun, computeReport, initMeasurementRecord, BILLING_DELTA_CRITERION, BILLING_DELTA_RECORD_ROOT } from "../../core/billing-delta/billing-delta-record.js";
+const PRIVACY_NOTE = "Operator-run, local-first. compaction.dev makes NO provider call, reads NO credential, and has NO network access. " +
+    "All billing figures are operator-entered (read from YOUR provider console/billing export) and are NOT provider-verified by this tool. " +
+    "Aggregate cost only — no prompt/completion content is stored.";
+function recordPath(outDir) {
+    return path.join(outDir, "measurement-record.json");
+}
+function defaultOutputDir(workflowId) {
+    return path.join(BILLING_DELTA_RECORD_ROOT, workflowId);
+}
+async function loadRecord(outDir) {
+    const raw = await readFile(recordPath(outDir), "utf8");
+    return JSON.parse(raw);
+}
+async function readOptionalFile(filePath) {
+    if (!filePath)
+        return undefined;
+    return readFile(filePath, "utf8");
+}
+function resolveOutDir(out, workflow) {
+    if (out)
+        return out;
+    if (workflow)
+        return defaultOutputDir(workflow);
+    throw new Error("either --out <dir> or --workflow <id> is required to locate the measurement record");
+}
+// Console display only. Raw full-precision values stay in the JSON/markdown artifacts.
+function roundForConsole(value) {
+    if (value === null || value === undefined)
+        return "n/a";
+    return String(Number(value.toFixed(4)));
+}
+function buildReportMarkdown(report) {
+    const lines = [
+        "# Billing-Delta Measurement Report (operator-run A/B)",
+        "",
+        `**Measurement:** ${report.measurement_id} (workflow: ${report.workflow_id})`,
+        `**Generated at:** ${report.generated_at}`,
+        `**Verdict:** ${report.verdict}`,
+        "",
+        "> Operator-entered billing figures, not provider-verified by this tool. The tool made no provider call.",
+        "> This is NOT 'billing-confirmed savings' (Tier 3); it does not flip ValueProof.billing_confirmed_savings.claimed.",
+        "",
+        "## Fixed conditions",
+        "",
+        `- Model: ${report.fixed_conditions.model}`,
+        `- Model version: ${report.fixed_conditions.model_version}`,
+        `- Input: ${report.fixed_conditions.input_description}`,
+        `- Window: ${report.fixed_conditions.window}`,
+        "",
+        "## Arms (aggregate billed cost only)",
+        "",
+        `- Control:   n=${report.control.n}, mean=${report.control.mean ?? "n/a"}, min=${report.control.min ?? "n/a"}, max=${report.control.max ?? "n/a"}, sample_sd=${report.control.sample_sd ?? "n/a"}`,
+        `- Treatment: n=${report.treatment.n}, mean=${report.treatment.mean ?? "n/a"}, min=${report.treatment.min ?? "n/a"}, max=${report.treatment.max ?? "n/a"}, sample_sd=${report.treatment.sample_sd ?? "n/a"}`,
+        "",
+        "## Delta of means (control - treatment; positive = treatment cheaper)",
+        "",
+        `- mean_delta: ${report.mean_delta ?? "n/a"} ${report.currency ?? ""}`,
+        `- standard_error: ${report.delta_standard_error ?? "n/a"}`,
+        `- interval: ${report.delta_interval ? `[${report.delta_interval.lower}, ${report.delta_interval.upper}]` : "n/a"}`,
+        `- interval_excludes_zero: ${report.delta_interval_excludes_zero}`,
+        "",
+        "## Provider-reported token delta (token-level; never a billing claim)",
+        "",
+        `> ${report.token_delta.claim_label}`,
+        "",
+        `- status: ${report.token_delta.status}`,
+        `- Control:   n_with_tokens=${report.token_delta.control.n_with_tokens}, mean_input=${roundForConsole(report.token_delta.control.mean_input_tokens)}, input_deterministic=${report.token_delta.control.input_deterministic}, output min/max=${roundForConsole(report.token_delta.control.output_min)}/${roundForConsole(report.token_delta.control.output_max)}`,
+        `- Treatment: n_with_tokens=${report.token_delta.treatment.n_with_tokens}, mean_input=${roundForConsole(report.token_delta.treatment.mean_input_tokens)}, input_deterministic=${report.token_delta.treatment.input_deterministic}, output min/max=${roundForConsole(report.token_delta.treatment.output_min)}/${roundForConsole(report.token_delta.treatment.output_max)}`,
+        `- input_token_delta: ${roundForConsole(report.token_delta.input_token_delta)}${report.token_delta.input_token_delta_pct !== null ? ` (${(report.token_delta.input_token_delta_pct * 100).toFixed(2)}% of control input)` : ""}`,
+        `- output_token_delta: ${roundForConsole(report.token_delta.output_token_delta)}`,
+        `- estimated_cost_delta: ${report.token_delta.estimated_cost_delta ? `${report.token_delta.estimated_cost_delta.amount_usd.toFixed(4)} USD (${report.token_delta.estimated_cost_delta.cost_source} — an estimate, never billed)` : "n/a"}`,
+        `- task_quality: control=[${report.token_delta.task_quality.control.join(", ") || "none"}] treatment=[${report.token_delta.task_quality.treatment.join(", ") || "none"}] any_failed=${report.token_delta.task_quality.any_failed}`,
+        ...report.token_delta.notes.map((n) => `- note: ${n}`),
+        "",
+        "## Criterion",
+        "",
+        `- ${report.criterion}`,
+        "",
+        "## Verdict notes",
+        "",
+        ...report.verdict_notes.map((n) => `- ${n}`),
+        "",
+        "## Claim scope (this workflow / these conditions / this N ONLY)",
+        "",
+        `- ${report.claim_scope}`,
+        `- not_a_general_claim: ${report.not_a_general_claim}`,
+        "",
+        "## Confounders recorded",
+        "",
+        ...(report.confounders.length > 0 ? report.confounders.map((c) => `- ${c}`) : ["- (none recorded)"]),
+        "",
+        "## Treatment provenance links",
+        "",
+        ...(report.treatment_provenance_links.length > 0
+            ? report.treatment_provenance_links.map((l) => `- ${l.apply_approval_record_path} (sha256: ${l.apply_approval_record_sha256})`)
+            : ["- (none)"]),
+        "",
+        "## Caveats",
+        "",
+        ...report.caveats.map((c) => `- ${c}`),
+        ""
+    ];
+    return lines.join("\n");
+}
+export function registerBillingDeltaCommand(program) {
+    const billingDelta = program
+        .command("billing-delta")
+        .description("Operator-run, local-first billing-delta measurement record (A/B protocol). The OPERATOR runs both arms " +
+        "and enters billed costs from their own provider console. compaction.dev makes no provider call, reads no " +
+        "credential, and emits no billing-confirmed savings claim. Produces a measured, caveated, scoped delta only.");
+    billingDelta
+        .command("init")
+        .description("Create a measurement record: workflow id/description, fixed conditions (model+version, input, window), optional apply-approval link.")
+        .requiredOption("--workflow <id>", "Workflow id (also the default output dir under .compaction/billing-delta/<id>/)")
+        .requiredOption("--description <text>", "Plain-language workflow description")
+        .requiredOption("--model <name>", "Model identifier held fixed across both arms")
+        .option("--model-version <version>", "Pinned model version where the provider exposes it (default: unknown)")
+        .requiredOption("--input <text>", "Description of the fixed input/task (a description, NOT the content)")
+        .requiredOption("--window <text>", "Time/pricing window the arms are run in")
+        .option("--apply-approval-record <path>", "Optional path to the apply-approval-record JSON from `apply-context` (treatment-context provenance). Recorded by path + hash.")
+        .option("--out <dir>", "Output directory for the measurement record (default: .compaction/billing-delta/<workflow>/)")
+        .action(async (options) => {
+        console.log(chalk.cyan("compaction billing-delta init"));
+        console.log(PRIVACY_NOTE);
+        const outDir = options.out ?? defaultOutputDir(options.workflow);
+        const applyApprovalRecordContent = await readOptionalFile(options.applyApprovalRecord);
+        const record = initMeasurementRecord({
+            workflowId: options.workflow,
+            workflowDescription: options.description,
+            model: options.model,
+            modelVersion: options.modelVersion,
+            inputDescription: options.input,
+            window: options.window,
+            generatedAt: new Date().toISOString(),
+            applyApprovalRecordPath: options.applyApprovalRecord,
+            applyApprovalRecordContent
+        });
+        const written = await writeJsonArtifact(outDir, "measurement-record.json", record);
+        console.log(chalk.green(`Wrote ${written}`));
+        console.log(`Measurement id: ${record.measurement_id}`);
+        console.log("Next: compaction billing-delta add-run --arm control|treatment --cost <n> --currency <c> --timestamp <iso> --out " + outDir);
+    });
+    billingDelta
+        .command("add-run")
+        .description("Append a run: arm (control|treatment), operator-entered billed cost (+currency), optional provider-reported usage, timestamp, notes/confounders, optional treatment apply-approval link.")
+        .requiredOption("--arm <arm>", "control | treatment")
+        .requiredOption("--cost <number>", "Operator-entered billed cost read from YOUR provider console/billing export")
+        .requiredOption("--currency <code>", "Currency code (e.g. USD)")
+        .requiredOption("--timestamp <iso>", "Run timestamp (ISO 8601)")
+        .option("--notes <text>", "Notes / confounders (cache state, retries, version drift). Aggregate, non-content.")
+        .option("--input-tokens <n>", "Optional provider-reported input tokens (aggregate)")
+        .option("--output-tokens <n>", "Optional provider-reported output tokens (aggregate)")
+        .option("--total-tokens <n>", "Optional provider-reported total tokens (aggregate)")
+        .option("--apply-approval-record <path>", "For treatment runs: optional path to the apply-approval-record JSON (the compacted-context provenance). Recorded by path + hash.")
+        .option("--out <dir>", "Directory of the measurement record")
+        .option("--workflow <id>", "Workflow id (used to locate the record under .compaction/billing-delta/<id>/ if --out is omitted)")
+        .action(async (options) => {
+        console.log(chalk.cyan("compaction billing-delta add-run"));
+        console.log(PRIVACY_NOTE);
+        if (options.arm !== "control" && options.arm !== "treatment") {
+            console.error("error: --arm must be 'control' or 'treatment'.");
+            process.exitCode = 1;
+            return;
+        }
+        const cost = Number(options.cost);
+        if (!Number.isFinite(cost)) {
+            console.error("error: --cost must be a number.");
+            process.exitCode = 1;
+            return;
+        }
+        const outDir = resolveOutDir(options.out, options.workflow);
+        const record = await loadRecord(outDir);
+        const usage = options.inputTokens || options.outputTokens || options.totalTokens
+            ? {
+                ...(options.inputTokens ? { input_tokens: Number(options.inputTokens) } : {}),
+                ...(options.outputTokens ? { output_tokens: Number(options.outputTokens) } : {}),
+                ...(options.totalTokens ? { total_tokens: Number(options.totalTokens) } : {})
+            }
+            : undefined;
+        const treatmentApprovalRecordContent = await readOptionalFile(options.applyApprovalRecord);
+        const updated = addRun(record, {
+            arm: options.arm,
+            billedCost: cost,
+            currency: options.currency,
+            runTimestamp: options.timestamp,
+            notes: options.notes,
+            providerReportedUsage: usage,
+            treatmentApprovalRecordPath: options.applyApprovalRecord,
+            treatmentApprovalRecordContent
+        });
+        const written = await writeJsonArtifact(outDir, "measurement-record.json", updated);
+        const added = updated.runs[updated.runs.length - 1];
+        console.log(chalk.green(`Recorded ${added.arm} run ${added.run_id} (operator_entered=true). Wrote ${written}`));
+        const nControl = updated.runs.filter((r) => r.arm === "control").length;
+        const nTreatment = updated.runs.filter((r) => r.arm === "treatment").length;
+        console.log(`Runs so far: control=${nControl}, treatment=${nTreatment}`);
+    });
+    billingDelta
+        .command("report")
+        .description("Compute per-arm N/mean/min/max/sample-SD, the delta of means, and a caveated verdict (insufficient_data | inconclusive | measured_caveated_delta).")
+        .option("--out <dir>", "Directory of the measurement record")
+        .option("--workflow <id>", "Workflow id (used to locate the record if --out is omitted)")
+        .action(async (options) => {
+        console.log(chalk.cyan("compaction billing-delta report"));
+        console.log(PRIVACY_NOTE);
+        const outDir = resolveOutDir(options.out, options.workflow);
+        const record = await loadRecord(outDir);
+        const report = computeReport(record, new Date().toISOString());
+        const writtenJson = await writeJsonArtifact(outDir, "billing-delta-report.json", report);
+        const writtenMd = await writeTextArtifact(outDir, "billing-delta-report.md", buildReportMarkdown(report));
+        console.log(`Verdict: ${chalk.bold(report.verdict)}`);
+        console.log(`Criterion: ${BILLING_DELTA_CRITERION}`);
+        console.log(`Control:   n=${report.control.n}, mean=${roundForConsole(report.control.mean)}, sample_sd=${roundForConsole(report.control.sample_sd)}`);
+        console.log(`Treatment: n=${report.treatment.n}, mean=${roundForConsole(report.treatment.mean)}, sample_sd=${roundForConsole(report.treatment.sample_sd)}`);
+        console.log(`Delta of means (control - treatment): ${roundForConsole(report.mean_delta)} ${report.currency ?? ""}`);
+        if (report.delta_interval) {
+            console.log(`Interval: [${roundForConsole(report.delta_interval.lower)}, ${roundForConsole(report.delta_interval.upper)}] (excludes zero: ${report.delta_interval_excludes_zero})`);
+        }
+        for (const note of report.verdict_notes) {
+            console.log(chalk.yellow(`- ${note}`));
+        }
+        const td = report.token_delta;
+        console.log(`Token delta (${td.status}): ${td.claim_label}`);
+        if (td.status === "computed") {
+            console.log(`  input_token_delta: ${roundForConsole(td.input_token_delta)}` +
+                (td.input_token_delta_pct !== null ? ` (${(td.input_token_delta_pct * 100).toFixed(2)}% of control input)` : "") +
+                `; output_token_delta: ${roundForConsole(td.output_token_delta)}`);
+            console.log(`  estimated_cost_delta: ${td.estimated_cost_delta ? `${td.estimated_cost_delta.amount_usd.toFixed(4)} USD (price_table_estimate — an estimate, never billed)` : "n/a"}; ` +
+                `task any_failed=${td.task_quality.any_failed}`);
+        }
+        else {
+            for (const n of td.notes)
+                console.log(chalk.yellow(`  ${n}`));
+        }
+        console.log("Claim scope: " + report.claim_scope);
+        console.log("not_a_general_claim: " + report.not_a_general_claim + "; billing_confirmed: " + report.billing_confirmed);
+        console.log(chalk.green(`Wrote ${writtenJson}`));
+        console.log(chalk.green(`Wrote ${writtenMd}`));
+    });
+}
+//# sourceMappingURL=billing-delta.js.map

package/dist/cli/commands/capture-claude-code.d.ts

@@ -0,0 +1,19 @@
+interface DiscoverClaudeCodeOptions {
+    projectsDir?: string;
+}
+interface CaptureClaudeCodeOptions {
+    session: string;
+    out?: string;
+    maxToolResultChars?: string;
+    includeSubagents?: boolean;
+}
+export declare function captureClaudeCodeCommand(options: CaptureClaudeCodeOptions): Promise<void>;
+/**
+ * Discover local Claude Code sessions (metadata only) and print, for each, the
+ * ready-to-run `capture claude-code --session <path>` command (guided capture).
+ *
+ * Local and read-only: scans the projects directory only, makes no network call
+ * and no upload, and never prints session message content — metadata only.
+ */
+export declare function discoverClaudeCodeCommand(options: DiscoverClaudeCodeOptions): Promise<void>;
+export {};