specproof 0.2.0 → 0.3.0

package/README.md

@@ -1,53 +1,61 @@
-<img src="public/banner.png" alt="SpecProof" />
+<img src="https://raw.githubusercontent.com/Durable-Quality/specproof/main/public/icon.png" alt="SpecProof" width="120" />
 
 # SpecProof
 
-A standalone Next.js app that renders an audit view of any repo's API test coverage: every OpenAPI operation and response status, cross-examined against the repo's test assertions. Click a stamped verdict to read the test itself.
+Audit your API test coverage against your OpenAPI spec. SpecProof cross-examines every operation and response status in the spec against your test suite's assertions and renders the verdicts as a browsable report. Click any verdict to read the test that proves it, or see exactly what's untested.
 
-Point it at a repo the same way OpenAPI tooling works when installed into one — no repo-specific configuration is baked in:
-
-- **Sources of truth** (read from the target repo, `SPECPROOF_REPO`): the OpenAPI spec (auto-discovered `openapi*.json` / `swagger*.json`, or set `SPECPROOF_SPEC`) + the repo's `*.test.ts` files, parsed from `describe("METHOD /path")` blocks and `.status).toBe(NNN)` assertions. `{param}`, `[param]`, and `:param` path segments are treated as equivalent when matching.
-- **Generator**: `scripts/generate-proof.ts` compiles them into `app/proof.generated.json` — checked in, deterministic, regenerated automatically before `dev`/`build`.
-- **Consumer**: the app renders the checked-in artifact; no target checkout is needed to build or deploy.
-- **Drift guard**: `app/proof-contract.test.ts` fails CI when the artifact is stale relative to the spec/tests, when the proof doesn't cover exactly the spec's operations, or when a quoted snippet no longer points at a real `it()` block. It self-skips when no target repo is configured.
-
-## Setup
+## Quick start
 
 Requires [Bun](https://bun.sh).
 
 ```bash
-bun install
-SPECPROOF_REPO=/path/to/your-repo bun run dev   # compiles the proof, then serves on http://localhost:3001
+bun add -d specproof     # or npm install -D specproof
+bunx specproof dev       # audit the current repo → http://localhost:3001
 ```
 
-`SPECPROOF_REPO` defaults to the current working directory, so running the generator from inside the target repo needs no configuration at all. If the spec isn't named `openapi*.json` / `swagger*.json`, point `SPECPROOF_SPEC` at it (relative to the repo root).
+The OpenAPI spec is auto-discovered (`openapi*.json` / `swagger*.json`); tests are your `*.test.ts` / `*.test.tsx` / `*.test.js` files.
 
-## Commands
+## CLI
 
 ```bash
-bun run dev             # generate:proof + next dev (port 3001)
-bun run build           # generate:proof + next build
-bun run start           # serve the production build (port 3001)
-bun run generate:proof  # regenerate app/proof.generated.json only
-bun run test:unit       # contract tests (self-skip without a configured target repo)
-bun run lint            # ESLint + tsc
+specproof generate [--out proof.json] [--check]   # compile the coverage proof
+specproof dev                                     # generate + serve the report
+specproof build && specproof start                # production build + serve
 ```
 
-## Updating the proof
+| Option | Env var | Meaning |
+| --- | --- | --- |
+| `--repo <path>` | `SPECPROOF_REPO` | Repo to audit (default: current directory) |
+| `--spec <path>` | `SPECPROOF_SPEC` | Spec file, relative to the repo root, when auto-discovery doesn't apply |
+| `--out <path>` | `SPECPROOF_OUT` | Where `generate` writes the proof |
+| `--port <port>` | | Port for `dev` / `start` (default: 3001) |
 
-When the target repo's tests or OpenAPI spec change, the checked-in artifact goes stale and the contract tests fail. The fix:
+## Drift guard in CI
+
+Commit the proof next to your code, then have CI fail whenever the spec or tests change without regenerating it:
 
 ```bash
-SPECPROOF_REPO=/path/to/your-repo bun run generate:proof
-git add app/proof.generated.json && git commit
+specproof generate --out specproof.json           # regenerate + commit
+specproof generate --out specproof.json --check   # CI: exits 1 when stale
 ```
 
 ## Conventions the parser relies on
 
-- Test suites titled `describe("METHOD /path")` (`GET|POST|PUT|DELETE|PATCH`) — the path is matched against the spec's paths.
+- Test suites titled `describe("METHOD /path")` (`GET|POST|PUT|DELETE|PATCH`). The path is matched against the spec's paths; `{param}`, `[param]`, and `:param` segments are equivalent.
 - Status assertions written as `.status).toBe(NNN)` or `.status).toEqual(NNN)`.
 - Prettier-consistent formatting: `it()`/`test()` blocks are extracted by indentation, not a full parser.
 
-## Releasing
+## Development
+
+```bash
+bun install
+bun run dev         # audits the bundled example/ fixture on port 3001
+bun run test:unit   # analyzer unit tests + proof drift guards
+bun run lint        # ESLint + tsc
+```
+
+Point a checkout at a real repo with `SPECPROOF_REPO=/path/to/repo bun run dev`. See [CLAUDE.md](CLAUDE.md) for architecture notes.
+
+## License
 
-Merges to `main` run the [Release workflow](.github/workflows/release.yml), which publishes the package to npm whenever `package.json`'s version isn't on the registry yet (requires the `NPM_TOKEN` repository secret).
+MIT

package/components/CoverageProof.tsx

@@ -370,8 +370,8 @@ export function CoverageProof({
           >
             <p className="text-sm font-semibold tracking-[0.14em]">NO API DEFINITION PROVIDED</p>
             <div className="mt-4 flex flex-col gap-1 text-xs text-muted-foreground">
-              <code className="text-foreground/70">SPECPROOF_REPO=/path/to/repo</code>
-              <code className="text-foreground/70">bun run generate:proof</code>
+              <code className="text-foreground/70">specproof dev --repo /path/to/repo</code>
+              <code className="text-foreground/70">specproof generate --spec path/to/openapi.json</code>
             </div>
           </section>
         ) : (

package/next.config.js

@@ -1,6 +1,9 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   reactStrictMode: false,
+  // The app is built from source even when installed under node_modules
+  // (`specproof dev`/`build`); without this, Next's loaders skip its files.
+  transpilePackages: ['specproof'],
 };
 
 export default nextConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specproof",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Audit view of a repo's API test coverage: every OpenAPI operation and response status, cross-examined against the repo's test assertions.",
   "license": "MIT",
   "repository": "github:Durable-Quality/specproof",
@@ -13,6 +13,22 @@
     "audit"
   ],
   "type": "module",
+  "bin": {
+    "specproof": "scripts/cli.ts"
+  },
+  "files": [
+    "app",
+    "components",
+    "lib",
+    "scripts",
+    "!app/proof-contract.test.ts",
+    "!app/proof.generated.json",
+    "!lib/api-test-coverage.test.ts",
+    "next.config.js",
+    "postcss.config.js",
+    "tailwind.config.ts",
+    "tsconfig.json"
+  ],
   "scripts": {
     "build": "bun run generate:proof && bunx next build",
     "dev": "bun run generate:proof && bunx next dev --port 3001",
@@ -28,29 +44,29 @@
   "dependencies": {
     "@radix-ui/react-accordion": "^1.2.16",
     "@radix-ui/react-dialog": "^1.1.15",
+    "@types/node": "24.1.0",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "autoprefixer": "^10.4.22",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react": "^0.562.0",
     "next": "^16.0.7",
+    "postcss": "^8.5.6",
+    "postcss-import": "^16.1.1",
     "react": "19.2.3",
     "react-dom": "19.2.3",
     "tailwind-merge": "^3.4.0",
-    "tailwindcss-animate": "^1.0.7"
+    "tailwindcss": "^3.4.18",
+    "tailwindcss-animate": "^1.0.7",
+    "typescript": "^5.9.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
-    "@types/node": "24.1.0",
-    "@types/react": "^19.2.0",
-    "@types/react-dom": "^19.2.0",
-    "autoprefixer": "^10.4.22",
     "eslint": "^9.39.1",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.0.1",
     "globals": "^16.5.0",
-    "postcss": "^8.5.6",
-    "postcss-import": "^16.1.1",
-    "tailwindcss": "^3.4.18",
-    "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.1",
     "vitest": "^4.1.8"
   }

package/scripts/cli.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+// SpecProof CLI — the entrypoint when the package is installed into a target
+// repo (`bunx specproof <command>`). Audits the repo it is run from (override
+// with --repo / SPECPROOF_REPO) while Next.js dev/build/start run against the
+// SpecProof package directory itself, wherever it is installed.
+
+import path from 'path';
+import { createRequire } from 'module';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const appRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const USAGE = `specproof — audit a repo's API test coverage against its OpenAPI spec
+
+Usage: specproof <command> [options]
+
+Commands:
+  generate   Compile the coverage proof from the target repo's spec + tests
+  dev        generate, then serve the audit view with next dev
+  build      generate, then production-build the audit view
+  start      Serve the production build
+
+Options:
+  --repo <path>   Repo to audit (default: current directory; env SPECPROOF_REPO)
+  --spec <path>   OpenAPI spec, relative to the repo root when the auto-discovery
+                  of openapi*.json / swagger*.json doesn't apply (env SPECPROOF_SPEC)
+  --out <path>    generate only: where to write the proof (default: the app's
+                  bundled artifact; env SPECPROOF_OUT)
+  --check         generate only: verify the proof at --out is up to date instead
+                  of writing — exits 1 on drift (the CI guard)
+  --port <port>   dev/start only: port to serve on (default: 3001)
+`;
+
+function fail(message: string): never {
+  console.error(`specproof: ${message}\n\n${USAGE}`);
+  process.exit(1);
+}
+
+const [command, ...rest] = process.argv.slice(2);
+
+let port = '3001';
+const generateArgs: string[] = [];
+for (let i = 0; i < rest.length; i++) {
+  const arg = rest[i];
+  const value = () => {
+    const v = rest[++i];
+    if (!v) fail(`${arg} requires a value`);
+    return v;
+  };
+  // --repo/--spec become env vars so the analyzer (which reads them at import
+  // time) picks them up when the generator is dynamically imported below.
+  if (arg === '--repo') process.env.SPECPROOF_REPO = value();
+  else if (arg === '--spec') process.env.SPECPROOF_SPEC = value();
+  else if (arg === '--port') port = value();
+  else if (arg === '--out' || arg === '--check') {
+    if (command !== 'generate') fail(`${arg} only applies to the generate command`);
+    generateArgs.push(arg);
+    if (arg === '--out') generateArgs.push(value());
+  } else fail(`unknown option: ${arg}`);
+}
+
+function generate(argv: string[]): number {
+  // Dynamic import so the env vars set above are read, not the values at CLI
+  // startup. require() keeps this synchronous under Bun and Node alike.
+  const require = createRequire(import.meta.url);
+  const { parseGenerateArgs, runGenerate } = require('./generate-proof') as
+    typeof import('./generate-proof');
+  return runGenerate(parseGenerateArgs(argv));
+}
+
+function nextCli(...args: string[]): number {
+  const require = createRequire(import.meta.url);
+  // Resolve Next's bin relative to this package so the CLI works no matter
+  // where the consumer's package manager hoisted the dependency tree.
+  const nextBin = require.resolve('next/dist/bin/next', { paths: [appRoot] });
+  const result = spawnSync(process.execPath, [nextBin, ...args], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+  return result.status ?? 1;
+}
+
+switch (command) {
+  case 'generate':
+    process.exit(generate(generateArgs));
+    break;
+  case 'dev':
+  case 'build': {
+    // dev/build always refresh the bundled artifact — it is what the app
+    // renders. A consumer's committed copy (--out) is generate's concern.
+    const generated = generate([]);
+    if (generated !== 0) process.exit(generated);
+    process.exit(
+      command === 'dev'
+        ? nextCli('dev', appRoot, '--port', port)
+        : nextCli('build', appRoot)
+    );
+    break;
+  }
+  case 'start':
+    process.exit(nextCli('start', appRoot, '--port', port));
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case undefined:
+    console.log(USAGE);
+    process.exit(command ? 0 : 1);
+    break;
+  default:
+    fail(`unknown command: ${command}`);
+}

package/scripts/generate-proof.ts

@@ -4,16 +4,24 @@
 // SPECPROOF_SPEC).
 //
 // Run via `bun run generate:proof` (also runs automatically before
-// `bun run dev` / `bun run build`). The output is checked in at
-// app/proof.generated.json; the proof-contract test fails if it goes stale
-// relative to the spec or the tests. When no target spec is found, the
-// existing artifact is left untouched so the app still builds and renders.
+// `bun run dev` / `bun run build`), or `specproof generate` when installed.
+// The output defaults to the checked-in artifact at app/proof.generated.json;
+// override with --out / SPECPROOF_OUT to write the proof into the audited
+// repo instead (e.g. to commit it there). --check verifies the output file is
+// up to date without writing — the CI drift guard. When no target spec is
+// found, the existing artifact is left untouched so the app still builds and
+// renders.
 
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
-import { buildCoverageReport, resolveSpecPath, TARGET_REPO_ROOT } from '../lib/api-test-coverage';
+import {
+  buildCoverageReport,
+  resolveSpecPath,
+  TARGET_REPO_ROOT,
+  type CoverageReport,
+} from '../lib/api-test-coverage';
 
 const appRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -26,24 +34,99 @@ export function buildProof(): Record<string, unknown> {
   return buildCoverageReport() as unknown as Record<string, unknown>;
 }
 
-const isMain =
-  process.argv[1] &&
-  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+export interface GenerateOptions {
+  /** Where to write (or, with check, what to verify). Resolved against cwd.
+   *  Defaults to SPECPROOF_OUT, then the app's checked-in artifact. */
+  out?: string;
+  /** Verify the file at `out` matches a fresh proof instead of writing. */
+  check?: boolean;
+}
+
+/** Parses --out <path> / --check from a generate argv slice. Throws on
+ *  anything unrecognized so callers surface their own usage text. */
+export function parseGenerateArgs(argv: string[]): GenerateOptions {
+  const options: GenerateOptions = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--check') {
+      options.check = true;
+    } else if (arg === '--out') {
+      const value = argv[++i];
+      if (!value) throw new Error('--out requires a path');
+      options.out = value;
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+  return options;
+}
+
+export function runGenerate(options: GenerateOptions = {}): number {
+  const outPath = path.resolve(
+    options.out ?? process.env.SPECPROOF_OUT ?? GENERATED_PROOF_PATH
+  );
+  const relative = path.relative(process.cwd(), outPath);
+  const outLabel = relative && !relative.startsWith('..') ? relative : outPath;
 
-if (isMain) {
   if (!resolveSpecPath()) {
-    console.warn(
-      `generate-proof: no OpenAPI spec found under ${TARGET_REPO_ROOT} — ` +
-        'set SPECPROOF_REPO to the repo to audit (or SPECPROOF_SPEC to the spec file); keeping the existing proof'
-    );
-    process.exit(0);
+    const hint =
+      `no OpenAPI spec found under ${TARGET_REPO_ROOT} — ` +
+      'set SPECPROOF_REPO to the repo to audit (or SPECPROOF_SPEC to the spec file)';
+    if (options.check) {
+      // A drift check with nothing to check against is a failure, not a skip:
+      // CI asked us to verify the proof and we can't.
+      console.error(`generate-proof: ${hint}`);
+      return 1;
+    }
+    if (!fs.existsSync(outPath)) {
+      // The artifact is not published with the package, so a fresh install has
+      // no proof at all. Write an empty one: the app needs the file to build,
+      // and an empty report renders the "no API definition" state.
+      const empty: CoverageReport = {
+        tags: [],
+        operationCount: 0,
+        coveredCount: 0,
+        totalCount: 0,
+        untestedOperations: 0,
+      };
+      fs.writeFileSync(outPath, JSON.stringify(empty, null, 2) + '\n');
+      console.warn(`generate-proof: ${hint}; wrote an empty proof to ${outLabel}`);
+      return 0;
+    }
+    console.warn(`generate-proof: ${hint}; keeping the existing proof`);
+    return 0;
   }
+
   const proof = buildProof();
   const operationCount = (proof.operationCount as number) ?? 0;
   if (operationCount === 0) {
     console.error('generate-proof: no operations found in the OpenAPI spec — refusing to write an empty proof');
-    process.exit(1);
+    return 1;
   }
-  fs.writeFileSync(GENERATED_PROOF_PATH, JSON.stringify(proof, null, 2) + '\n');
-  console.log(`generate-proof: wrote ${path.relative(appRoot, GENERATED_PROOF_PATH)} (${operationCount} operations)`);
+  const serialized = JSON.stringify(proof, null, 2) + '\n';
+
+  if (options.check) {
+    const existing = fs.existsSync(outPath) ? fs.readFileSync(outPath, 'utf8') : null;
+    if (existing !== serialized) {
+      console.error(
+        `generate-proof: ${outLabel} is stale relative to the spec/tests — ` +
+          'regenerate it (specproof generate) and commit the result'
+      );
+      return 1;
+    }
+    console.log(`generate-proof: ${outLabel} is up to date (${operationCount} operations)`);
+    return 0;
+  }
+
+  fs.writeFileSync(outPath, serialized);
+  console.log(`generate-proof: wrote ${outLabel} (${operationCount} operations)`);
+  return 0;
+}
+
+const isMain =
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMain) {
+  process.exit(runGenerate(parseGenerateArgs(process.argv.slice(2))));
 }

package/.github/workflows/release.yml

@@ -1,49 +0,0 @@
-name: 🚀 Release
-
-on:
-  push:
-    branches: main
-
-permissions:
-  contents: read
-  id-token: write # npm provenance
-
-jobs:
-  publish:
-    name: 🚀 Publish to npm
-    runs-on: ubuntu-latest
-
-    env:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-    steps:
-      - name: 📥 Checkout code
-        uses: actions/checkout@v5
-
-      - name: 🟢 Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          registry-url: https://registry.npmjs.org
-
-      - name: 🔎 Skip if this version is already on npm
-        id: check
-        run: |
-          NAME=$(node -p "require('./package.json').name")
-          VERSION=$(node -p "require('./package.json').version")
-          if npm view "$NAME@$VERSION" version >/dev/null 2>&1; then
-            echo "::notice::$NAME@$VERSION is already published — nothing to do"
-            echo "published=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "published=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: ⚠️ Warn when NPM_TOKEN is missing
-        if: steps.check.outputs.published == 'false' && env.NPM_TOKEN == ''
-        run: echo "::warning::NPM_TOKEN secret is not set — skipping npm publish. Add it under Settings → Secrets and variables → Actions."
-
-      - name: 🚀 Publish to npm
-        if: steps.check.outputs.published == 'false' && env.NPM_TOKEN != ''
-        run: npm publish --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/test-unit.yml

@@ -1,69 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches: main
-  merge_group:
-  push:
-    branches: main
-  workflow_dispatch:
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: 📥 Checkout code
-        uses: actions/checkout@v5
-
-      - name: 🍞 Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: 🧰 Install dependencies
-        run: bun install
-
-      - name: 🏗️ Build
-        run: bun run build
-
-  lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: 📥 Checkout code
-        uses: actions/checkout@v5
-
-      - name: 🍞 Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: 🧰 Install dependencies
-        run: bun install
-
-      - name: 🧹 ESLint
-        run: bun run lint:es
-
-      - name: 🔎 Typecheck
-        run: bun run lint:ts
-
-  test:
-    name: Test
-    runs-on: ubuntu-latest
-    env:
-      NODE_ENV: test
-    steps:
-      - name: 📥 Checkout code
-        uses: actions/checkout@v5
-
-      - name: 🍞 Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: 🧰 Install dependencies
-        run: bun install
-
-      - name: 🧾 Run unit & contract tests
-        run: bun run test:unit

package/CHANGELOG.md

@@ -1,47 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.2.0] - 2026-07-14
-
-### Added
-- Bundled `example/` demo target: the fictional TaskFlow API (7 operations) plus fixture test files, audited automatically when no `SPECPROOF_REPO` is set — the app now renders a meaningful proof out of the box, demonstrating every verdict state.
-- Unit test suite for the coverage analyzer (`lib/api-test-coverage.test.ts`, 30 tests): path-param normalization, snippet extraction, test-file parsing, spec discovery, evidence merging, and report assembly with independently computed expectations.
-- CI workflow with separate `Build`, `Lint`, and `Test` jobs, running on pull requests and in the merge queue.
-- Merge queue ruleset on `main`: PRs required, all CI checks must pass, no direct pushes.
-- Marketing showcase page (`marketing/`) and brand assets (`public/`), with a banner in the README.
-
-### Changed
-- Releases now publish only after a PR merges to `main` through the merge queue; the manual release trigger was removed.
-- `buildCoverageReport()` accepts an optional target repo root, and the analyzer's parsing internals are exported for testing.
-- Larger SpecProof masthead in the coverage view.
-
-## [0.1.0] - 2026-07-13
-
-### Added
-- Initial public release under new name SpecProof (npm package `specproof`).
-- GitHub Actions release workflow: automatically publishes to npm when package version is updated.
-- Comprehensive project documentation in CLAUDE.md.
-- Generalized spec/test discovery: auto-discovers OpenAPI specs (`openapi*.json`, `swagger*.json`) and test files in any target repo; no longer OmniLens-specific.
-- Support for explicit spec path via `SPECPROOF_SPEC` environment variable.
-
-### Changed
-- **Breaking**: Renamed environment variable `OMNILENS_REPO` → `SPECPROOF_REPO` for specifying the target repo to audit.
-- **Breaking**: Renamed environment variable `OMNILENS_SPEC` → `SPECPROOF_SPEC` for specifying the OpenAPI spec path.
-- Renamed npm package from `test-ledger` to `specproof`.
-- Renamed generator script `scripts/generate-ledger.ts` → `scripts/generate-proof.ts` and npm command `generate:ledger` → `generate:proof`.
-- Renamed generated artifact `app/ledger.generated.json` → `app/proof.generated.json`.
-- Renamed contract test file `app/ledger-contract.test.ts` → `app/proof-contract.test.ts`.
-- Renamed stylesheet `app/ledger.css` → `app/proof.css`.
-- Renamed React component `CoverageLedger` → `CoverageProof`.
-- Updated CSS class prefix `lg-` → `sp-` throughout the codebase.
-- Generalized code comments and documentation from OmniLens-specific to target-agnostic language.
-- GitHub Actions workflow `test-unit.yml` renamed to "Proof Contract Tests" with updated environment variable references.
-- Removed `"private": true` from package.json to allow npm publishing.
-- Updated package.json metadata: added `repository`, `homepage`, `description`, and `keywords`.
-
-### Removed
-- OmniLens-specific hardcoded paths and configuration.