@compaction/cli 0.1.2 → 0.2.0

package/README.md

@@ -24,6 +24,14 @@ Everything below runs on your machine and writes local files only:
   billing-confirmed**.
 - **Inspect spend and roll up runs.** `spend`, `summary`, and `aggregate` summarize where context
   spend came from and roll up local runs — local files only, no hosted dashboard.
+- **Build a local context store and retrieve from it.** `context add` accumulates source-pointed
+  items from a captured/imported trace into a local, size-capped store; `context get`
+  deterministically retrieves and assembles the active context for a query under a token budget,
+  printing it **with source pointers** plus local retrieval **diagnostics** (what was
+  considered / included / dropped, the recoverable fraction, latency). Local-only and
+  deterministic — **no model, no embeddings, no network**. It reports **diagnostics only** (no
+  quality or sufficiency verdict on your data) and makes **no savings claim** (see `spend` /
+  `summary` for cost).
 - **Write local reports.** `analyze` writes local JSON + Markdown reports under an
   operator-chosen output directory. Local files only.
 - **Create redacted, content-free share bundles.** `feedback --redact` writes a redacted,
@@ -66,7 +74,7 @@ npx @compaction/cli --help       # no install at all
 ```
 
 The installed binary is `compaction`. After a global install, sanity-check with
-`compaction --version` (→ `0.1.2`) and `compaction --help`.
+`compaction --version` (→ `0.2.0`) and `compaction --help`.
 
 ### curl one-liner
 
@@ -133,6 +141,8 @@ compaction capture provider-usage --endpoint <url> [--credential-env-var <NAME>]
 compaction import <trace-file> --source <source> --out <dir>
 compaction import --list-sources
 compaction analyze <trace-file>
+compaction context add <trace-file>             # build a local context store from a captured/imported trace
+compaction context get "<query>"                # retrieve + assemble the active context (with source pointers)
 compaction spend <trace-or-optimization-path>   # context-spend attribution
 compaction summary                               # roll up local run reports
 compaction aggregate                             # per-session / cross-session local rollups

package/dist/cli/commands/compact.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import chalk from "chalk";
 import { Option } from "commander";
 import { writeJsonArtifact, writeTextArtifact } from "../../core/artifact-writer.js";
+import { formatCompactionMarkdownReport, withSavingsEvidence, withTraceFingerprint } from "../../core/report-generator.js";
 import { describeTokenAccounting } from "../../core/token-accounting.js";
 import { parseTraceFile } from "../../core/trace-parser.js";
 import { buildRunLabelsFile, hasAnyLabel } from "../../core/run-labels.js";
@@ -123,6 +124,20 @@ export function registerCompactCommand(program) {
             // hand-assembled bundle — the eval consumes the identical PolicyMiddlewareResult.
             const policyResult = applyCompactionPolicy({ trace, compactSkillInjections: approveSkillInjectionPolicy });
             const artifacts = await writeCompactionArtifacts(trace, options.out, runId, policyResult, undefined, { reviewerType, reviewSummaryPresent, approveSkillInjectionPolicy });
+            // Attribution/integrity + per-run evidence label (V0.2 savings-evidence): re-persist
+            // report.json with (1) the content-addressed trace fingerprint so `aggregate`/`summary` can
+            // attribute each saving to a verifiable run and de-duplicate a run rolled up twice, and
+            // (2) the composed `savings_evidence` record stating the per-run label explicitly. The
+            // compact path's figures are local estimates (chars/4) — `local_estimate` rung 1; never
+            // billing-confirmed, never semantic. Additive, backward-compatible; changes no existing field.
+            const evidenceReport = withSavingsEvidence(withTraceFingerprint(artifacts.report, trace), {
+                costSource: "local_estimate"
+            });
+            await writeJsonArtifact(options.out, "report.json", evidenceReport);
+            // Re-render report.md from the ENRICHED report so the per-run savings_evidence record
+            // appears in the human-readable artifact too (the engine rendered report.md from the base
+            // report before the CLI added the public-layer fingerprint/evidence enrichment).
+            await writeTextArtifact(options.out, "report.md", formatCompactionMarkdownReport(evidenceReport, artifacts.policy));
             console.log(chalk.cyan("compaction compact"));
             console.log(artifacts.consoleReport);
             // Operator-visible only when the approval gesture was given; default output is unchanged.

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

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

package/dist/cli/commands/context.js

@@ -0,0 +1,130 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { assembleContext, contextItemsFromTrace, retrieveContextItems } from "../../core/context-store.js";
+import { appendContextItems, loadContextStore } from "../../core/context-store-fs.js";
+/**
+ * V0.4 `compaction context` — a LOCAL memory + retrieval surface over the user's own captured
+ * traces (design: docs/design/v0.4-context-command.md, accepted 2026-06-24).
+ *
+ * HARD RAILS (load-bearing): local-only — no network, no model, no embeddings, no engine. It
+ * makes NO savings/cost claim (cost lives in `spend`/`summary`) and NO quality/recall/correctness
+ * verdict on user data (the four-axis sufficiency harness stays internal — there is no ground
+ * truth for an arbitrary user query). `get` prints local retrieval DIAGNOSTICS only.
+ */
+const DEFAULT_STORE_DIR = ".compaction/context-store";
+function readTrace(path) {
+    if (!existsSync(path)) {
+        throw new Error(`File not found: ${path}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error(`Not valid JSON: ${path}`);
+    }
+    const trace = parsed;
+    if (!trace || typeof trace.id !== "string" || !Array.isArray(trace.messages)) {
+        throw new Error("Not a normalized AgentTrace (expected { id, messages: [...] }). " +
+            "Produce one with `compaction capture` or `compaction import`.");
+    }
+    for (const message of trace.messages) {
+        const m = message;
+        if (!m || typeof m.id !== "string" || typeof m.content !== "string") {
+            throw new Error("Malformed trace: every message needs a string `id` and `content`. " +
+                "Produce a trace with `compaction capture` or `compaction import`.");
+        }
+    }
+    return parsed;
+}
+function collect(value, previous) {
+    return [...previous, value];
+}
+export function registerContextCommand(program) {
+    const context = program
+        .command("context")
+        .description("Local memory: build a durable context store from your own captured/imported traces and " +
+        "retrieve the active context for a next step (local-only; no model, no network, no savings claim).");
+    context
+        .command("add")
+        .argument("<artifact>", "Path to a local normalized AgentTrace JSON (from `compaction capture`/`import`)")
+        .option("--store-dir <dir>", "Context store directory (local, gitignored)", DEFAULT_STORE_DIR)
+        .description("Append context items derived from a local trace into the local context store (size-cap enforced).")
+        .action(async (artifact, options) => {
+        const storeDir = resolve(options.storeDir ?? DEFAULT_STORE_DIR);
+        const trace = readTrace(resolve(artifact));
+        const items = contextItemsFromTrace(trace, { created_at: new Date().toISOString() });
+        const result = await appendContextItems(storeDir, items);
+        console.log(chalk.cyan("compaction context add"));
+        console.log(`Source: ${artifact}`);
+        console.log(`Store: ${storeDir}`);
+        console.log(`Items added: ${result.appended.length}   skipped (duplicate): ${result.skipped.length}   ` +
+            `evicted (size cap): ${result.evicted.length}`);
+        console.log(`Store now holds: ${result.total} items.`);
+        console.log("Local-only: nothing was uploaded. This makes no savings claim (see `compaction spend`/`summary` for cost).");
+        console.log(chalk.bold('Next: compaction context get "<your query>"'));
+    });
+    context
+        .command("get")
+        .argument("<query>", "Free-text description of the current step")
+        .option("--store-dir <dir>", "Context store directory (local, gitignored)", DEFAULT_STORE_DIR)
+        .option("--budget <tokens>", "Token budget for the assembled context (local estimate)", "4000")
+        .option("--source <pointer>", "Required source pointer for coverage diagnostics (repeatable)", collect, [])
+        .option("--limit <n>", "Max candidate items to consider after ranking")
+        .description("Retrieve + assemble the active context for a query from the local store (deterministic, local). " +
+        "Prints the assembled context WITH source pointers + local retrieval diagnostics — not a quality score.")
+        .action(async (query, options) => {
+        const storeDir = resolve(options.storeDir ?? DEFAULT_STORE_DIR);
+        const budget = Number.parseInt(options.budget ?? "4000", 10);
+        if (Number.isNaN(budget) || budget < 0) {
+            console.error("--budget must be a non-negative integer number of tokens.");
+            process.exitCode = 1;
+            return;
+        }
+        let limit;
+        if (options.limit !== undefined) {
+            limit = Number.parseInt(options.limit, 10);
+            if (Number.isNaN(limit) || limit < 0) {
+                console.error("--limit must be a non-negative integer.");
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const items = await loadContextStore(storeDir);
+        const retrievalOptions = limit !== undefined ? { limit } : {};
+        const start = performance.now();
+        const ranked = retrieveContextItems(items, { text: query, source_pointers: options.source && options.source.length > 0 ? options.source : undefined }, retrievalOptions);
+        const assembled = assembleContext(ranked, { tokenBudget: budget });
+        const latencyMs = performance.now() - start;
+        console.log(chalk.cyan("compaction context get"));
+        console.log(`Query: ${JSON.stringify(query)}`);
+        console.log(`Store: ${storeDir} (${items.length} items)`);
+        if (assembled.included.length === 0) {
+            console.log("Assembled context: (no matching context in the store for this query)");
+        }
+        else {
+            console.log(`Assembled context (~${assembled.estimated_tokens} tokens, local estimate; budget ${budget}):`);
+            for (const item of assembled.included) {
+                const pointer = item.source_pointer ?? "(no source pointer)";
+                const oneLine = item.content.replace(/\s+/g, " ");
+                console.log(`  [${pointer}] ${oneLine}`);
+            }
+        }
+        const recoverable = assembled.included.filter((i) => i.recoverability === true && i.source_pointer).length;
+        console.log("Diagnostics (local retrieval, not a quality score):");
+        console.log(`  considered: ${ranked.length}   included: ${assembled.included.length}   dropped: ${assembled.dropped.length}`);
+        console.log(`  recoverable (has source pointer): ${recoverable}/${assembled.included.length}`);
+        if (options.source && options.source.length > 0) {
+            const includedPointers = new Set(assembled.included.map((i) => i.source_pointer).filter((p) => Boolean(p)));
+            const covered = options.source.filter((s) => includedPointers.has(s)).length;
+            console.log(`  source coverage: ${covered}/${options.source.length}`);
+        }
+        else {
+            console.log("  source coverage: n/a (no --source given)");
+        }
+        console.log(`  latency: ${latencyMs.toFixed(1)} ms`);
+        console.log("No model, no network. Local memory/retrieval view — it makes no savings claim and no quality/correctness claim.");
+    });
+}
+//# sourceMappingURL=context.js.map

package/dist/cli/commands/import.js

@@ -5,8 +5,10 @@ function printSupportedSources() {
     console.log(chalk.cyan("compaction import sources"));
     for (const adapter of listTraceAdapters()) {
         console.log(`- ${adapter.id}: ${adapter.displayName}`);
+        console.log(`    readiness: ${adapter.readiness}`);
     }
-    console.log("Live provider/runtime integrations remain future work; codex-exec-jsonl reads only local export files.");
+    console.log("All sources are local file import (no live integration). Readiness above is an honest integration-readiness " +
+        "label (AGENTS.md Level 0–6) + validation status — not a stronger integration claim than the evidence supports.");
 }
 export function registerImportCommand(program) {
     program

package/dist/cli/commands/init.js

@@ -1,216 +1,243 @@
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
 import chalk from "chalk";
 import { defaultProjectsDir, discoverClaudeCodeSessions } from "../../core/adapters/claude-code-discovery.js";
+import { BRAND_HEX, VALUE_PROMISE, STATUS_PILLS, PRIMARY, SECONDARY, FREE_FLOW, HONESTY_LINES, FOOTER_LINES, ALL_WORKFLOW_KEYS } from "../onboarding/model.js";
+import { decideInteractiveTuiFromProcess } from "../onboarding/should-use-tui.js";
 /**
  * `compaction init` — first-run, value-led terminal onboarding.
  *
- * Converts "I installed a CLI" into "I am one command away from seeing my own
- * workflow's context waste." It is guidance plus ONE read-only local detection
- * (does a Claude Code projects directory exist, and how many sessions are in it).
+ * In a real interactive terminal this launches a graphical Ink TUI (a workflow
+ * chooser). Everywhere else — pipes, CI, NO_COLOR, dumb terminals, the test
+ * runner, `--static`, or `--path <focus>` — it prints the byte-stable static
+ * screen. Both surfaces share ONE model (`../onboarding/model`) so they always
+ * feature the same workflows, the same free follow-ups, and the same honest
+ * claim labels.
  *
- * Invariants (non-negotiable, hold on every path):
+ * Invariants (non-negotiable, hold on EVERY path — static and TUI):
  *  - writes nothing
  *  - makes no network call
  *  - reads no provider credential
  *  - needs no repo access
- * A provider credential is ONLY ever used if the operator explicitly runs
- * `capture provider-usage` (or enters operator-run measurement records).
+ * The TUI is a chooser, not an agent: no text input, no model call, no upload.
  *
- * Proprietary boundary (per mvp-plan.md §13): output names high-level waste
- * CATEGORIES and policy-FAMILY names plus before/after deltas, risk, safety,
- * approval requirement, artifacts, and the next action — never the proprietary
- * scoring formulas, thresholds, hidden heuristics, future-policy internals, or
- * commercial / moat logic.
+ * Free-CLI scope: onboarding features ONLY the free, local-first commands
+ * (capture / import / analyze / spend / summary / feedback). The optimization &
+ * verification engine commands (recommend / compact / inspect / approve /
+ * apply-context) are the opt-in Compaction API — NOT in the free CLI — and so
+ * are deliberately NOT featured here.
  *
- * Presentation note: this is a calm, structured, minimal first-run surface.
- * Hierarchy comes from spacing, dim secondary text, and a few restrained
- * symbols — not from a wall of enumerated text.
+ * Honesty rails: token counts are provider-reported when usage metadata is
+ * present, otherwise a labeled local estimate (chars/4); cost is a price-table
+ * estimate; nothing is called a saving until it is measured. No billing-confirmed,
+ * no semantic-preservation, no hosted-API-live, no auto-apply, no demo-first.
  */
-// Clean one-line wordmark. The hand-drawn ASCII banner read busy at small
-// terminal sizes; a spaced, bold mark with a rule under it reads premium.
-const MARK = chalk.bold("compaction");
+// Brand accent. chalk.hex degrades gracefully: on a non-color / non-truecolor
+// terminal chalk down-samples or no-ops, so the text is never lost.
+const ACCENT = chalk.hex(BRAND_HEX);
+// Spaced wordmark reads as a premium brand mark at any terminal width.
+const WORDMARK = ACCENT.bold("C O M P A C T I O N");
 const RULE = chalk.dim("─".repeat(58));
-const HEADLINE = "Context optimization for AI agents";
-const VALUE_PROP = chalk.dim("Reduce avoidable input/output tokens while preserving task-critical\n  context. Local-first — nothing is applied without your approval.");
-// The value loop, compressed to one line per step. Each step earns its place.
-const LOOP = [
-    ["capture", "a real trace from your own agent workflow"],
-    ["analyze", "where token spend and avoidable context waste are"],
-    ["recommend", "a candidate policy family + estimated before/after delta"],
-    ["compact", "the before/after token delta, and which family produced it"],
-    ["inspect", "safety evidence — source pointers, hashes, recoverable originals"],
-    ["approve", "emit a compacted context for your next call. No auto-apply."]
-];
-// Real-workflow paths only. compaction operates on the user's OWN agent
-// workflow; there is no demo / synthetic first-value path here. Demo fixtures
-// exist solely for tests, package smoke, and explicitly-labeled docs.
-const PRIMARY = {
-    key: "claude-code",
-    title: "Claude Code",
-    command: "compaction capture claude-code --discover"
-};
-const SECONDARY = [
-    {
-        key: "codex",
-        title: "Codex",
-        command: "codex exec --json '<task>' > run.jsonl  &&  compaction import run.jsonl --source codex-exec-jsonl --out ./my-trace"
-    },
-    {
-        key: "openai-agents",
-        title: "OpenAI Agents",
-        command: "compaction capture openai-agents --out ./my-trace -- <your-command>"
-    },
-    {
-        key: "import",
-        title: "Local trace",
-        command: "compaction import --list-sources   # then: import <file> --source <source> --out ./my-trace"
+async function readPackageVersion() {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        // dist/cli/commands -> dist -> package root
+        const pkgPath = path.resolve(here, "..", "..", "..", "package.json");
+        const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : "unknown";
     }
-];
-// The follow-up sequence is identical for every path once a trace exists.
-const FOLLOW_UP = [
-    "compaction analyze       ./my-trace/captured-trace.json",
-    "compaction recommend     ./my-trace/captured-trace.json",
-    "compaction compact       ./my-trace/captured-trace.json --out ./my-trace/compacted",
-    "compaction apply-context ./my-trace/captured-trace.json --out ./my-trace/apply"
-];
+    catch {
+        return "unknown";
+    }
+}
+async function detectClaudeCode(projectsDir) {
+    let claudeDetected = false;
+    let sessionCount = 0;
+    if (existsSync(projectsDir)) {
+        try {
+            const discovery = await discoverClaudeCodeSessions({ projectsDir });
+            sessionCount = discovery.sessions.length;
+            claudeDetected = sessionCount > 0;
+        }
+        catch {
+            claudeDetected = false; // detection is best-effort; onboarding never fails on it
+        }
+    }
+    return { claudeDetected, sessionCount, projectsDir };
+}
+// ---------------------------------------------------------------------------
+// Static screen (the universal fallback). Output is intentionally byte-stable:
+// scripts, snapshots, and smoke tests depend on it.
+// ---------------------------------------------------------------------------
 function header(text) {
     return chalk.bold(text);
 }
-function loopBlock() {
-    const width = Math.max(...LOOP.map(([verb]) => verb.length));
-    return LOOP.map(([verb, desc]) => `  ${chalk.cyan(verb.padEnd(width))}  ${chalk.dim(desc)}`);
-}
 function primaryBlock(sessionCount) {
-    const tag = chalk.green(`   ✓ ${sessionCount} session(s) found`);
+    const tag = chalk.green(`  ✓ ${sessionCount} session(s) found`);
     return [
-        `${chalk.bold("▸ " + PRIMARY.title)}${chalk.dim("  · recommended")}${tag}`,
-        `  ${chalk.cyan(PRIMARY.command)}`
+        `${chalk.bold("▸ " + PRIMARY.title)}${chalk.dim("  · recommended first run")}${tag}`,
+        `  ${ACCENT(PRIMARY.command)}`
     ];
 }
-function secondaryBlock() {
-    const lines = [chalk.dim("Other workflows")];
-    for (const p of SECONDARY) {
-        lines.push(`  ${chalk.dim(p.title)}`);
-        lines.push(`    ${chalk.cyan(p.command)}`);
-    }
-    return lines;
-}
 function emptyStateBlock(projectsDir) {
-    // Calm, premium no-sessions state: explain, show how to create one, and give
-    // the exact rerun command. The secondary real paths follow below.
     return [
-        `${chalk.bold("▸ " + PRIMARY.title)}${chalk.dim("  · recommended")}`,
+        `${chalk.bold("▸ " + PRIMARY.title)}${chalk.dim("  · recommended first run")}`,
         chalk.dim(`  No sessions found under ${projectsDir}.`),
         chalk.dim("  Start or run a Claude Code session in any project, then re-run:"),
-        `    ${chalk.cyan("compaction capture claude-code --discover")}`
+        `    ${ACCENT("compaction capture claude-code --discover")}`
     ];
 }
+function supportedBlock() {
+    const summary = "Claude Code · OpenAI Agents SDK · Codex / local import · local trace import";
+    const lines = [header("Supported workflows"), `  ${chalk.dim(summary)}`, ""];
+    for (const p of SECONDARY) {
+        lines.push(`  ${chalk.bold(p.title)}`);
+        lines.push(`    ${ACCENT(p.command)}`);
+    }
+    return lines;
+}
 function afterCaptureBlock() {
+    const width = Math.max(...FREE_FLOW.map((f) => f.command.length));
     return [
         header("Then, on the trace you captured"),
         "",
-        ...FOLLOW_UP.map((c) => `  ${chalk.cyan(c)}`),
+        ...FREE_FLOW.map((f) => `  ${ACCENT(f.command.padEnd(width))}  ${chalk.dim(f.desc)}`),
+        "",
+        chalk.dim(`  ${HONESTY_LINES[0]}`),
+        chalk.dim(`  ${HONESTY_LINES[1]}`),
+        chalk.dim(`  ${HONESTY_LINES[2]}`),
         "",
-        chalk.dim("  You'll see: waste pattern CATEGORY, high-level POLICY FAMILY,"),
-        chalk.dim("  before/after input/output tokens, the TOKEN-COUNT SOURCE"),
-        chalk.dim("  (provider-reported vs estimated — never an estimate as reported),"),
-        chalk.dim("  RISK LEVEL, safety + source_recoverability, the APPROVAL REQUIREMENT"),
-        chalk.dim("  (--approve-in-workflow-use; no auto-apply), and the next action.")
+        chalk.dim(`  ${HONESTY_LINES[3]}`),
+        chalk.dim(`  ${HONESTY_LINES[4]}`)
     ];
 }
 function footerBlock() {
-    return [
-        chalk.dim("Local-first: no network, no credentials, no repo access for any of the above."),
-        chalk.dim("A provider credential is only ever used if YOU explicitly run"),
-        chalk.dim("`compaction capture provider-usage` or enter operator-run records.")
+    return FOOTER_LINES.map((l) => chalk.dim(l));
+}
+function buildStaticScreen(version, focus, det) {
+    const lines = [];
+    // 1. Wordmark + status + value promise.
+    lines.push("");
+    lines.push(`  ${WORDMARK}`);
+    lines.push("");
+    lines.push(`  ${chalk.dim(`v${version} · ${STATUS_PILLS.join(" · ")}`)}`);
+    lines.push("");
+    lines.push(`  ${VALUE_PROMISE}`);
+    lines.push("");
+    lines.push(RULE);
+    lines.push("");
+    // 2. Start here — primary path (Claude Code) or a focused secondary path.
+    if (!focus || focus === "claude-code") {
+        lines.push(header("Start here"));
+        lines.push("");
+        if (det.claudeDetected) {
+            lines.push(...primaryBlock(det.sessionCount));
+        }
+        else {
+            lines.push(...emptyStateBlock(det.projectsDir));
+        }
+        lines.push("");
+        if (!focus) {
+            lines.push(...supportedBlock());
+            lines.push("");
+        }
+    }
+    else {
+        const p = SECONDARY.find((s) => s.key === focus);
+        lines.push(header("Start here"));
+        lines.push("");
+        lines.push(`  ${chalk.bold(p.title)}`);
+        lines.push(`    ${ACCENT(p.command)}`);
+        lines.push("");
+    }
+    lines.push(RULE);
+    lines.push("");
+    // 3. The free follow-up sequence + honest labeling + opt-in-API positioning.
+    lines.push(...afterCaptureBlock());
+    lines.push("");
+    lines.push(RULE);
+    lines.push("");
+    // 4. Local-first footer.
+    lines.push(...footerBlock());
+    lines.push("");
+    return lines.join("\n");
+}
+// After the TUI exits with a selection, print a clean, copy-ready next-command
+// block to the scrollback so the user can paste and run it.
+function printSelection(card) {
+    const out = [
+        "",
+        `${chalk.bold("▸ " + card.title)}`,
+        chalk.dim(`  ${card.blurb}`),
+        "",
+        chalk.dim("  Run this next:"),
+        `    ${ACCENT(card.command)}`,
+        "",
+        chalk.dim(`  Then: ${FREE_FLOW.map((f) => f.command.replace("compaction ", "")).join(" · ")}`),
+        chalk.dim("  Local-first: no network, no credentials, no upload. Nothing is called a"),
+        chalk.dim("  saving until it is measured."),
+        ""
     ];
+    console.log(out.join("\n"));
 }
 export function registerInitCommand(program) {
     program
         .command("init")
-        .description("First-run onboarding: the value loop, how to capture YOUR first real trace, and the exact next commands. " +
-        "Guidance + one read-only local detection only — writes nothing, no network, no credentials.")
-        .option("--path <path>", "Focus one input path: claude-code | codex | openai-agents | import")
+        .description("First-run onboarding: an interactive workflow chooser in a real terminal (TUI), or the " +
+        "value promise + exact next commands as a static screen elsewhere. Guidance + one read-only " +
+        "local detection only — writes nothing, no network, no credentials.")
+        .option("--path <path>", "Focus one input path: claude-code | openai-agents | codex | import")
         .option("--projects-dir <dir>", "Claude Code projects directory to detect against (default: the standard local location)")
+        .option("--interactive", "prefer the interactive TUI; if no TTY is available, show the static screen and why")
+        .option("--static", "always show the plain static screen (no TUI)")
         .action(async (options) => {
         // Validate --path early so the error stays a clean one-liner.
-        const allKeys = [PRIMARY.key, ...SECONDARY.map((p) => p.key)];
-        if (options.path && !allKeys.includes(options.path)) {
-            console.error(`unknown --path '${options.path}'. Valid: ${allKeys.join(" | ")}`);
+        if (options.path && !ALL_WORKFLOW_KEYS.includes(options.path)) {
+            console.error(`unknown --path '${options.path}'. Valid: ${ALL_WORKFLOW_KEYS.join(" | ")}`);
             process.exitCode = 1;
             return;
         }
+        // Version read at runtime so it always matches the installed package.
+        const version = await readPackageVersion();
         // Read-only local detection (no writes, no network).
         const projectsDir = options.projectsDir ?? defaultProjectsDir();
-        let claudeDetected = false;
-        let sessionCount = 0;
-        if (existsSync(projectsDir)) {
-            try {
-                const discovery = await discoverClaudeCodeSessions({ projectsDir });
-                sessionCount = discovery.sessions.length;
-                claudeDetected = sessionCount > 0;
-            }
-            catch {
-                claudeDetected = false; // detection is best-effort; onboarding never fails on it
-            }
-        }
+        const det = await detectClaudeCode(projectsDir);
+        // Decide static vs interactive. A focused path (--path) or --static always
+        // serves static; --interactive forces the TUI iff a TTY is present;
+        // otherwise auto-detect.
+        // Note: --interactive cannot conjure a TTY (raw-mode keyboard nav needs
+        // one), so it does not override the TTY check; it only documents intent.
+        // When asked for but unavailable, we fall back to static with a reason.
         const focus = options.path;
-        const lines = [];
-        // 1. Mark + value prop.
-        lines.push("");
-        lines.push(`${MARK}  ${chalk.dim("·")}  ${HEADLINE}`);
-        lines.push(`  ${VALUE_PROP}`);
-        lines.push("");
-        lines.push(RULE);
-        lines.push("");
-        // 2. The value loop — what the tool actually does, one line per step.
-        lines.push(header("How it works"));
-        lines.push("");
-        lines.push(...loopBlock());
-        lines.push("");
-        lines.push(chalk.dim("  Estimates are labeled as estimates; provider-reported as provider-reported."));
-        lines.push(chalk.dim("  Nothing is called a saving until it is measured."));
-        lines.push("");
-        lines.push(RULE);
-        lines.push("");
-        // 3. Start here — primary path (Claude Code) or a focused secondary path.
-        if (!focus || focus === "claude-code") {
-            lines.push(header("Start here"));
-            lines.push("");
-            if (claudeDetected) {
-                lines.push(...primaryBlock(sessionCount));
+        const ttyDecision = decideInteractiveTuiFromProcess();
+        const wantTui = !focus && !options.static && ttyDecision.useTui;
+        if (wantTui) {
+            // Dynamic import keeps Ink/React off every non-TTY code path.
+            const { runInitTui } = await import("../onboarding/InitTui.js");
+            const result = await runInitTui({
+                version,
+                detection: {
+                    detected: det.claudeDetected,
+                    sessionCount: det.sessionCount,
+                    projectsDir: det.projectsDir
+                }
+            });
+            if (result.action === "select") {
+                printSelection(result.card);
             }
             else {
-                lines.push(...emptyStateBlock(projectsDir));
-            }
-            lines.push("");
-            // 4. Secondary real-workflow paths (compact, secondary styling).
-            //    Only on the default (unfocused) view.
-            if (!focus) {
-                lines.push(...secondaryBlock());
-                lines.push("");
+                console.log(chalk.dim("\nNo workflow selected. Run `compaction init` anytime.\n"));
             }
+            return;
         }
-        else {
-            // Focused secondary path.
-            const p = SECONDARY.find((s) => s.key === focus);
-            lines.push(header("Start here"));
-            lines.push("");
-            lines.push(`  ${chalk.bold(p.title)}`);
-            lines.push(`    ${chalk.cyan(p.command)}`);
-            lines.push("");
+        // If the user explicitly asked for --interactive but we are not in a TTY,
+        // tell them why we fell back, then serve the static screen.
+        if (options.interactive && !ttyDecision.useTui) {
+            console.error(chalk.dim(`(interactive TUI unavailable here: ${ttyDecision.reason}; showing static screen)`));
         }
-        lines.push(RULE);
-        lines.push("");
-        // 5. The follow-up sequence + what to expect.
-        lines.push(...afterCaptureBlock());
-        lines.push("");
-        lines.push(RULE);
-        lines.push("");
-        // 6. Local-first footer.
-        lines.push(...footerBlock());
-        lines.push("");
-        console.log(lines.join("\n"));
+        console.log(buildStaticScreen(version, focus, det));
     });
 }
 //# sourceMappingURL=init.js.map